*/
#include <config.h>
+#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <gtk/gtk.h>
#include "gdk-pixbuf.h"
-#include "gdk-pixbuf-io.h"
#include "gdk-pixbuf-loader.h"
typedef struct {
pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
- if (!pixbuf->art_pixbuf) {
- g_warning ("art_pixbuf is NULL in expose_func!!\n");
- return;
- }
-
- if (pixbuf->art_pixbuf->has_alpha) {
+ if (gdk_pixbuf_get_has_alpha (pixbuf)) {
gdk_draw_rgb_32_image (drawing_area->window,
drawing_area->style->black_gc,
event->area.x, event->area.y,
event->area.width,
event->area.height,
GDK_RGB_DITHER_MAX,
- pixbuf->art_pixbuf->pixels
- + (event->area.y * pixbuf->art_pixbuf->rowstride)
- + (event->area.x * pixbuf->art_pixbuf->n_channels),
- pixbuf->art_pixbuf->rowstride);
+ gdk_pixbuf_get_pixels (pixbuf)
+ + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf))
+ + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+ gdk_pixbuf_get_rowstride (pixbuf));
} else {
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
event->area.width,
event->area.height,
GDK_RGB_DITHER_NORMAL,
- pixbuf->art_pixbuf->pixels
- + (event->area.y * pixbuf->art_pixbuf->rowstride)
- + (event->area.x * pixbuf->art_pixbuf->n_channels),
- pixbuf->art_pixbuf->rowstride);
+ gdk_pixbuf_get_pixels (pixbuf)
+ + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf))
+ + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+ gdk_pixbuf_get_rowstride (pixbuf));
}
}
pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
#if 0
- if (((event->width) != (pixbuf->art_pixbuf->width)) ||
- ((event->height) != (pixbuf->art_pixbuf->height)))
+ if (((event->width) != gdk_pixbuf_get_width (pixbuf)) ||
+ ((event->height) != gdk_pixbuf_get_height (pixbuf)))
gdk_pixbuf_scale(pixbuf, event->width, event->height);
#endif
}
GtkWidget *drawing_area;
gint w, h;
- w = pixbuf->art_pixbuf->width;
- h = pixbuf->art_pixbuf->height;
+ w = gdk_pixbuf_get_width (pixbuf);
+ h = gdk_pixbuf_get_height (pixbuf);
window = gtk_widget_new (gtk_window_get_type (),
"GtkObject::user_data", NULL,
return window;
}
+#if 0
static gint
update_timeout(gpointer data)
return;
}
+#endif
+
static int readlen = 4096;
int
int found_valid = FALSE;
GdkPixbufAnimation *animation;
- GdkPixbufLoader *pixbuf_loader;
gtk_init (&argc, &argv);
if (animation) {
gint i = 0;
GList *listptr;
- for (listptr = animation->frames; listptr; listptr = listptr->next){
+ for (listptr = gdk_pixbuf_animation_get_frames (animation);
+ listptr;
+ listptr = listptr->next) {
+ GdkPixbufFrame *frame;
+ GdkPixbuf *pixbuf;
gchar *title;
+
+ frame = listptr->data;
+ pixbuf = gdk_pixbuf_frame_get_pixbuf (frame);
+
title = g_strdup_printf ("Frame %d", i);
g_print ("Frame %d x:%d y:%d width:%d height:%d\n",
i,
- ((GdkPixbufFrame *)listptr->data)->x_offset,
- ((GdkPixbufFrame *)listptr->data)->y_offset,
- gdk_pixbuf_get_width (((GdkPixbufFrame *)listptr->data)->pixbuf),
- gdk_pixbuf_get_height (((GdkPixbufFrame *)listptr->data)->pixbuf));
- new_testrgb_window (((GdkPixbufFrame *)listptr->data)->pixbuf, title);
+ gdk_pixbuf_frame_get_x_offset (frame),
+ gdk_pixbuf_frame_get_y_offset (frame),
+ gdk_pixbuf_get_width (pixbuf),
+ gdk_pixbuf_get_height (pixbuf));
+ new_testrgb_window (pixbuf, title);
g_free (title);
i++;
}
{
GtkWidget* rgb_window = NULL;
ProgressFileStatus status;
+ GdkPixbufLoader *pixbuf_loader;
pixbuf_loader = gdk_pixbuf_loader_new ();
status.loader = pixbuf_loader;
pixbuf = (GdkPixbuf *) gtk_object_get_data(GTK_OBJECT(drawing_area),
"pixbuf");
- if(pixbuf->art_pixbuf->has_alpha)
+ if(gdk_pixbuf_get_has_alpha (pixbuf))
{
gdk_draw_rgb_32_image(drawing_area->window,
drawing_area->style->black_gc,
evt->area.width,
evt->area.height,
GDK_RGB_DITHER_MAX,
- pixbuf->art_pixbuf->pixels +
- (evt->area.y * pixbuf->art_pixbuf->rowstride) +
- (evt->area.x * pixbuf->art_pixbuf->n_channels),
- pixbuf->art_pixbuf->rowstride);
+ gdk_pixbuf_get_pixels (pixbuf) +
+ (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) +
+ (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+ gdk_pixbuf_get_rowstride (pixbuf));
}
else
{
evt->area.width,
evt->area.height,
GDK_RGB_DITHER_NORMAL,
- pixbuf->art_pixbuf->pixels +
- (evt->area.y * pixbuf->art_pixbuf->rowstride) +
- (evt->area.x * pixbuf->art_pixbuf->n_channels),
- pixbuf->art_pixbuf->rowstride);
+ gdk_pixbuf_get_pixels (pixbuf) +
+ (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) +
+ (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+ gdk_pixbuf_get_rowstride (pixbuf));
}
return FALSE;
}
"pixbuf");
g_print("X:%d Y:%d\n", evt->width, evt->height);
- if(evt->width != pixbuf->art_pixbuf->width || evt->height != pixbuf->art_pixbuf->height)
+ if(evt->width != gdk_pixbuf_get_width (pixbuf) || evt->height != gdk_pixbuf_get_height (pixbuf))
{
GdkWindow *root;
GdkPixbuf *new_pixbuf;
drawing_area = gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(drawing_area),
- pixbuf->art_pixbuf->width,
- pixbuf->art_pixbuf->height);
+ gdk_pixbuf_get_width (pixbuf),
+ gdk_pixbuf_get_height (pixbuf));
gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event",
GTK_SIGNAL_FUNC(expose_cb), NULL);
#include <stdio.h>
-ArtFilterLevel filter_level = ART_FILTER_BILINEAR;
+GdkInterpType interp_type = GDK_INTERP_BILINEAR;
int overall_alpha = 255;
GdkPixbuf *pixbuf;
GtkWidget *darea;
void
-set_filter_level (GtkWidget *widget, gpointer data)
+set_interp_type (GtkWidget *widget, gpointer data)
{
- filter_level = GPOINTER_TO_UINT (data);
+ interp_type = GPOINTER_TO_UINT (data);
gtk_widget_queue_draw (darea);
}
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
- dest = gdk_pixbuf_new (ART_PIX_RGB, FALSE, 8, event->area.width, event->area.height);
+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, event->area.width, event->area.height);
gdk_pixbuf_composite_color (pixbuf, dest,
0, 0, event->area.width, event->area.height,
-event->area.x, -event->area.y,
- (double) widget->allocation.width / pixbuf->art_pixbuf->width,
- (double) widget->allocation.height / pixbuf->art_pixbuf->height,
- filter_level, overall_alpha,
+ (double) widget->allocation.width / gdk_pixbuf_get_width (pixbuf),
+ (double) widget->allocation.height / gdk_pixbuf_get_height (pixbuf),
+ interp_type, overall_alpha,
event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
gdk_pixbuf_render_to_drawable (dest, widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
menuitem = gtk_menu_item_new_with_label ("NEAREST");
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
- GTK_SIGNAL_FUNC (set_filter_level),
- GUINT_TO_POINTER (ART_FILTER_NEAREST));
+ GTK_SIGNAL_FUNC (set_interp_type),
+ GUINT_TO_POINTER (GDK_INTERP_NEAREST));
gtk_widget_show (menuitem);
gtk_container_add (GTK_CONTAINER (menu), menuitem);
menuitem = gtk_menu_item_new_with_label ("BILINEAR");
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
- GTK_SIGNAL_FUNC (set_filter_level),
- GUINT_TO_POINTER (ART_FILTER_BILINEAR));
+ GTK_SIGNAL_FUNC (set_interp_type),
+ GUINT_TO_POINTER (GDK_INTERP_BILINEAR));
gtk_widget_show (menuitem);
gtk_container_add (GTK_CONTAINER (menu), menuitem);
menuitem = gtk_menu_item_new_with_label ("TILES");
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
- GTK_SIGNAL_FUNC (set_filter_level),
- GUINT_TO_POINTER (ART_FILTER_TILES));
+ GTK_SIGNAL_FUNC (set_interp_type),
+ GUINT_TO_POINTER (GDK_INTERP_TILES));
gtk_container_add (GTK_CONTAINER (menu), menuitem);
menuitem = gtk_menu_item_new_with_label ("HYPER");
gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
- GTK_SIGNAL_FUNC (set_filter_level),
- GUINT_TO_POINTER (ART_FILTER_HYPER));
+ GTK_SIGNAL_FUNC (set_interp_type),
+ GUINT_TO_POINTER (GDK_INTERP_HYPER));
gtk_container_add (GTK_CONTAINER (menu), menuitem);
optionmenu = gtk_option_menu_new ();
GTK_SIGNAL_FUNC (expose_cb), NULL);
gtk_window_set_default_size (GTK_WINDOW (window),
- pixbuf->art_pixbuf->width,
- scratch_requisition.height + pixbuf->art_pixbuf->height);
+ gdk_pixbuf_get_width (pixbuf),
+ scratch_requisition.height + gdk_pixbuf_get_height (pixbuf));
gtk_widget_show_all (window);
-
/* testpixbuf -- test program for gdk-pixbuf code
* Copyright (C) 1999 Mark Crichton, Larry Ewing
*
*/
#include <config.h>
+#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <gtk/gtk.h>
#include "gdk-pixbuf.h"
-#include "gdk-pixbuf-io.h"
#include "gdk-pixbuf-loader.h"
typedef struct {
guchar *buf;
guint timeout;
guint readlen;
-
} ProgressFileStatus;
pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
- if (!pixbuf->art_pixbuf) {
- g_warning ("art_pixbuf is NULL in expose_func!!\n");
- return;
- }
-
- if (pixbuf->art_pixbuf->has_alpha) {
+ if (gdk_pixbuf_get_has_alpha (pixbuf)) {
gdk_draw_rgb_32_image (drawing_area->window,
drawing_area->style->black_gc,
event->area.x, event->area.y,
event->area.width,
event->area.height,
GDK_RGB_DITHER_MAX,
- pixbuf->art_pixbuf->pixels
- + (event->area.y * pixbuf->art_pixbuf->rowstride)
- + (event->area.x * pixbuf->art_pixbuf->n_channels),
- pixbuf->art_pixbuf->rowstride);
+ gdk_pixbuf_get_pixels (pixbuf)
+ + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf))
+ + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+ gdk_pixbuf_get_rowstride (pixbuf));
} else {
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
event->area.width,
event->area.height,
GDK_RGB_DITHER_NORMAL,
- pixbuf->art_pixbuf->pixels
- + (event->area.y * pixbuf->art_pixbuf->rowstride)
- + (event->area.x * pixbuf->art_pixbuf->n_channels),
- pixbuf->art_pixbuf->rowstride);
+ gdk_pixbuf_get_pixels (pixbuf)
+ + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf))
+ + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+ gdk_pixbuf_get_rowstride (pixbuf));
}
}
g_print("X:%d Y:%d\n", event->width, event->height);
#if 0
- if (((event->width) != (pixbuf->art_pixbuf->width)) ||
- ((event->height) != (pixbuf->art_pixbuf->height)))
+ if (((event->width) != gdk_pixbuf_get_width (pixbuf)) ||
+ ((event->height) != gdk_pixbuf_get_height (pixbuf)))
gdk_pixbuf_scale(pixbuf, event->width, event->height);
#endif
}
GtkWidget *drawing_area;
gint w, h;
- w = pixbuf->art_pixbuf->width;
- h = pixbuf->art_pixbuf->height;
+ w = gdk_pixbuf_get_width (pixbuf);
+ h = gdk_pixbuf_get_height (pixbuf);
window = gtk_widget_new (gtk_window_get_type (),
"GtkObject::user_data", NULL,
if (argc == 1) {
const gchar*** xpmp;
- pixbuf = gdk_pixbuf_new_from_data (default_image, ART_PIX_RGB, FALSE,
+ pixbuf = gdk_pixbuf_new_from_data (default_image, GDK_COLORSPACE_RGB, FALSE, 8,
DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_WIDTH * 3,
NULL, NULL);
new_testrgb_window (pixbuf, NULL);
+2000-04-11 Federico Mena Quintero <federico@helixcode.com>
+
+ Most of this patch is based on a patch by Havoc Pennington
+ (hp@redhat.com) to make GdkPixbuf's structures opaque and to
+ remove the libart dependency.
+
+ * gdk-pixbuf/gdk-pixbuf.h: Removed the public structures.
+ (GdkColorspace): New enum that for now only contains
+ GDK_COLORSPACE_RGB.
+ (GdkPixbufDestroyNotify): New type for the pixbuf's pixels destroy
+ notification function.
+ (GdkInterpType): New num with interpolation types.
+
+ * *.[ch]: Replace the libart stuff with our own stuff.
+
+ * pixops/*.[ch]: Likewise.
+
+ * gdk-pixbuf/gdk-pixbuf-private.h: New file with the private
+ declarations of the GdkPixbuf structures.
+
+ * gdk-pixbuf/gdk-pixbuf.c (gdk_pixbuf_new_from_art_pixbuf):
+ Removed function.
+ (gdk_pixbuf_get_format): Constify.
+ (gdk_pixbuf_get_n_channels): Constify.
+ (gdk_pixbuf_get_has_alpha): Constify.
+ (gdk_pixbuf_get_bits_per_sample): Constify.
+ (gdk_pixbuf_get_pixels): Constify.
+ (gdk_pixbuf_get_width): Constify.
+ (gdk_pixbuf_get_height): Constify.
+ (gdk_pixbuf_get_rowstride): Constify.
+
+ * gdk-pixbuf/gdk-pixbuf.c (gdk_pixbuf_copy): New function to copy
+ a pixbuf.
+
+ * gdk-pixbuf/gdk-pixbuf-data.c (gdk_pixbuf_new_from_data): Added a
+ bits_per_sample argument; currently only 8 bits per sample are
+ supported.
+
+ * gdk-pixbuf/gdk-pixbuf-animation.c (gdk_pixbuf_frame_get_pixbuf):
+ New accessor.
+ (gdk_pixbuf_frame_get_x_offset): New accessor.
+ (gdk_pixbuf_frame_get_y_offset): New accessor.
+ (gdk_pixbuf_frame_get_delay_time): New accessor.
+ (gdk_pixbuf_frame_get_action): New accessor.
+
+ * gdk-pixbuf/gdk-pixbuf-render.c
+ (gdk_pixbuf_render_pixmap_and_mask): Instead of returning a solid
+ mask rectangle for pixbufs without an alpha channel, set the
+ *mask_return to NULL.
+
+ * gdk-pixbuf/gdk-pixbuf-util.c (gdk_pixbuf_add_alpha): Constify.
+
+ * gdk-pixbuf/gdk-pixbuf-scale.c: Fix includes.
+
+ * gdk-pixbuf/gdk-pixbuf-scale.c (gdk_pixbuf_scale): Added some
+ preconditions. Maybe we should also check for the colorspace,
+ bits per pixel, and such.
+ (gdk_pixbuf_composite): Likewise.
+ (gdk_pixbuf_composite_color): Likewise.
+ (gdk_pixbuf_scale_simple): Likewise, and fail gracefully if we
+ cannot allocate the new pixbuf.
+ (gdk_pixbuf_composite_color_simple): Likewise.
+
+ * gdk-pixbuf/gnome-canvas-pixbuf.c (gnome_canvas_pixbuf_render):
+ Use art_rgb_rgba_affine() or art_rgb_affine() since we no longer
+ have an ArtPixBuf.
+
+ * gdk-pixbuf/io-bmp.c: Fix includes.
+
+ * gdk-pixbuf/pixops/pixops.c (pixops_scale_nearest): Fixed cast in
+ an lvalue.
+
+ * TODO: Populated.
+
+ * configure.in: Removed checks for libart.
+
+ * gdk-pixbuf/Makefile.am: Removed references to libart.
+ (noinst_HEADERS): Added gdk-pixbuf-private.h.
+
+ * gdk-pixbuf/Makefile.am (libgdk_pixbuf_la_LDFLAGS): Incremented
+ the version number of the libtool library to indicate that this
+ definitely is not compatible with the old usage. I know you love
+ me. I know you do.
+
+ * configure.in: Bumped version number to 0.7.0.
+
+ * README: Updated.
+
+ * gdk-pixbuf-config.in (--libs): We no longer require libart.
+
+ * DEPENDS.libgdk_pixbuf: We no longer depend on libart.
+
+ * gdk-pixbuf.spec.in: Updated, but I don't guarantee anything.
+
2000-04-06 Jonathan Blandford <jrb@redhat.com>
* gdk-pixbuf/testanimation.c (main): add more info to the
INCLUDES = -I$(top_srcdir) -I$(top_builddir) \
-I$(top_srcdir)/gdk-pixbuf \
-I$(top_builddir)/gdk-pixbuf \
- $(GLIB_CFLAGS) $(LIBART_CFLAGS) $(GTK_CFLAGS)
+ $(GLIB_CFLAGS) $(GTK_CFLAGS)
AM_CPPFLAGS = "-DPIXBUF_LIBDIR=\"$(libexecdir)\""
-LDADDS = libgdk_pixbuf.la $(LIBART_LIBS) $(GLIB_LIBS) $(GTK_LIBS) $(STATIC_LIB_DEPS)
+LDADDS = libgdk_pixbuf.la $(GLIB_LIBS) $(GTK_LIBS) $(STATIC_LIB_DEPS)
if INSIDE_GNOME_LIBS
-testpixbuf_LDADD = $(LDADDS) $(LIBART_LIBS) -lgmodule
+testpixbuf_LDADD = $(LDADDS) -lgmodule
testpixbuf_drawable_LDADD = $(LDADDS)
testpixbuf_scale_LDADD = $(LDADDS)
-testanimation_LDADD = $(LDADDS) $(LIBART_LIBS) -lgmodule
+testanimation_LDADD = $(LDADDS) -lgmodule
else
-testpixbuf_LDADD = $(LDADDS) $(LIBART_LIBS) $(GNOME_LIBS) -lgmodule
+testpixbuf_LDADD = $(LDADDS) $(GNOME_LIBS) -lgmodule
testpixbuf_drawable_LDADD = $(LDADDS) $(GNOME_LIBS)
testpixbuf_scale_LDADD = $(LDADDS) $(GNOME_LIBS)
-testanimation_LDADD = $(LDADDS) $(LIBART_LIBS) $(GNOME_LIBS) -lgmodule
+testanimation_LDADD = $(LDADDS) $(GNOME_LIBS) -lgmodule
endif
-GDK_PIXBUF_LIBS = $(LIBART_LIBS) $(GLIB_LIBS) $(GTK_LIBS)
+GDK_PIXBUF_LIBS = $(GLIB_LIBS) $(GTK_LIBS)
#
# The GdkPixBuf library
gdk-pixbuf-util.c \
$(extra_sources)
-libgdk_pixbuf_la_LDFLAGS = -version-info 1:0:0 $(LIBART_LIBS) $(GLIB_LIBS) $(GTK_LIBS)
-libgdk_pixbuf_la_LIBADD = pixops/libpixops.la
+libgdk_pixbuf_la_LDFLAGS = -version-info 2:0:0 $(GLIB_LIBS) $(GTK_LIBS)
+libgdk_pixbuf_la_LIBADD = pixops/libpixops.la
libgdk_pixbufinclude_HEADERS = \
gdk-pixbuf.h \
gdk-pixbuf-features.h \
$(CANVAS_PIXBUF_HEADERFILES)
-noinst_HEADERS = \
- gdk-pixbuf-io.h
-
+noinst_HEADERS = \
+ gdk-pixbuf-io.h \
+ gdk-pixbuf-private.h
#include <config.h>
#include "gdk-pixbuf-io.h"
+#include "gdk-pixbuf-private.h"
\f
return animation->frames;
}
+
+\f
+
+/**
+ * gdk_pixbuf_frame_get_pixbuf:
+ * @frame: A pixbuf animation frame.
+ *
+ * Queries the pixbuf of an animation frame.
+ *
+ * Return value: A pixbuf.
+ **/
+GdkPixbuf *
+gdk_pixbuf_frame_get_pixbuf (GdkPixbufFrame *frame)
+{
+ g_return_val_if_fail (frame != NULL, NULL);
+
+ return frame->pixbuf;
+}
+
+/**
+ * gdk_pixbuf_frame_get_x_offset:
+ * @frame: A pixbuf animation frame.
+ *
+ * Queries the X offset of an animation frame.
+ *
+ * Return value: X offset from the top left corner of the animation.
+ **/
+int
+gdk_pixbuf_frame_get_x_offset (GdkPixbufFrame *frame)
+{
+ g_return_val_if_fail (frame != NULL, -1);
+
+ return frame->x_offset;
+}
+
+/**
+ * gdk_pixbuf_frame_get_y_offset:
+ * @frame: A pixbuf animation frame.
+ *
+ * Queries the Y offset of an animation frame.
+ *
+ * Return value: Y offset from the top left corner of the animation.
+ **/
+int
+gdk_pixbuf_frame_get_y_offset (GdkPixbufFrame *frame)
+{
+ g_return_val_if_fail (frame != NULL, -1);
+
+ return frame->y_offset;
+}
+
+/**
+ * gdk_pixbuf_frame_get_delay_time:
+ * @frame: A pixbuf animation frame.
+ *
+ * Queries the delay time in milliseconds of an animation frame.
+ *
+ * Return value: Delay time in milliseconds.
+ **/
+int
+gdk_pixbuf_frame_get_delay_time (GdkPixbufFrame *frame)
+{
+ g_return_val_if_fail (frame != NULL, -1);
+
+ return frame->delay_time;
+}
+
+/**
+ * gdk_pixbuf_frame_get_action:
+ * @frame: A pixbuf animation frame.
+ *
+ * Queries the overlay action of an animation frame.
+ *
+ * Return value: Overlay action for this frame.
+ **/
+GdkPixbufFrameAction
+gdk_pixbuf_frame_get_action (GdkPixbufFrame *frame)
+{
+ g_return_val_if_fail (frame != NULL, GDK_PIXBUF_FRAME_RETAIN);
+
+ return frame->action;
+}
#include <config.h>
#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
\f
/**
* gdk_pixbuf_new_from_data:
* @data: Image data in 8-bit/sample packed format.
- * @format: Color format used for the data.
+ * @colorspace: Colorspace for the image data.
* @has_alpha: Whether the data has an opacity channel.
+ * @bits_per_sample: Number of bits per sample.
* @width: Width of the image in pixels.
* @height: Height of the image in pixels.
* @rowstride: Distance in bytes between rows.
- * @dfunc: Function used to free the data when the pixbuf's reference count
+ * @destroy_fn: Function used to free the data when the pixbuf's reference count
* drops to zero, or NULL if the data should not be freed.
- * @dfunc_data: Closure data to pass to the destroy notification function.
+ * @destroy_fn_data: Closure data to pass to the destroy notification function.
*
- * Creates a new #GdkPixbuf out of in-memory RGB data.
+ * Creates a new #GdkPixbuf out of in-memory image data. Currently only RGB
+ * images with 8 bits per sample are supported.
*
* Return value: A newly-created #GdkPixbuf structure with a reference count of
* 1.
**/
GdkPixbuf *
-gdk_pixbuf_new_from_data (const guchar *data, ArtPixFormat format, gboolean has_alpha,
- int width, int height, int rowstride,
- ArtDestroyNotify dfunc, gpointer dfunc_data)
+gdk_pixbuf_new_from_data (const guchar *data, GdkColorspace colorspace, gboolean has_alpha,
+ int bits_per_sample, int width, int height, int rowstride,
+ GdkPixbufDestroyNotify destroy_fn, gpointer destroy_fn_data)
{
- ArtPixBuf *art_pixbuf;
+ GdkPixbuf *pixbuf;
/* Only 8-bit/sample RGB buffers are supported for now */
g_return_val_if_fail (data != NULL, NULL);
- g_return_val_if_fail (format == ART_PIX_RGB, NULL);
+ g_return_val_if_fail (colorspace == GDK_COLORSPACE_RGB, NULL);
+ g_return_val_if_fail (bits_per_sample == 8, NULL);
g_return_val_if_fail (width > 0, NULL);
g_return_val_if_fail (height > 0, NULL);
- if (has_alpha)
- art_pixbuf = art_pixbuf_new_rgba_dnotify ((art_u8 *)data, width, height, rowstride,
- dfunc_data, dfunc);
- else
- art_pixbuf = art_pixbuf_new_rgb_dnotify ((art_u8 *)data, width, height, rowstride,
- dfunc_data, dfunc);
+ pixbuf = g_new (GdkPixbuf, 1);
+ pixbuf->ref_count = 1;
+ pixbuf->colorspace = colorspace;
+ pixbuf->n_channels = has_alpha ? 4 : 3;
+ pixbuf->bits_per_sample = bits_per_sample;
+ pixbuf->has_alpha = has_alpha ? TRUE : FALSE;
+ pixbuf->width = width;
+ pixbuf->height = height;
+ pixbuf->rowstride = rowstride;
+ pixbuf->pixels = (guchar *) data;
+ pixbuf->destroy_fn = destroy_fn;
+ pixbuf->destroy_fn_data = destroy_fn_data;
- g_assert (art_pixbuf != NULL);
-
- return gdk_pixbuf_new_from_art_pixbuf (art_pixbuf);
+ return pixbuf;
}
#include <config.h>
#include <string.h>
#include <glib.h>
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
\f
#include <config.h>
#include <gtk/gtksignal.h>
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-loader.h"
#include "gdk-pixbuf-io.h"
--- /dev/null
+/* GdkPixbuf library - Private declarations
+ *
+ * Copyright (C) 1999 The Free Software Foundation
+ *
+ * Authors: Mark Crichton <crichton@gimp.org>
+ * Miguel de Icaza <miguel@gnu.org>
+ * Federico Mena-Quintero <federico@gimp.org>
+ * Havoc Pennington <hp@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef GDK_PIXBUF_PRIVATE_H
+#define GDK_PIXBUF_PRIVATE_H
+
+#include "gdk-pixbuf.h"
+
+\f
+
+/* Private part of the GdkPixbuf structure */
+struct _GdkPixbuf {
+ /* Reference count */
+ int ref_count;
+
+ /* Color space */
+ GdkColorspace colorspace;
+
+ /* Number of channels, alpha included */
+ int n_channels;
+
+ /* Bits per channel */
+ int bits_per_sample;
+
+ /* Size */
+ int width, height;
+
+ /* Offset between rows */
+ int rowstride;
+
+ /* The pixel array */
+ guchar *pixels;
+
+ /* Destroy notification function; it is supposed to free the pixel array */
+ GdkPixbufDestroyNotify destroy_fn;
+
+ /* User data for the destroy notification function */
+ gpointer destroy_fn_data;
+
+ /* Do we have an alpha channel? */
+ guint has_alpha : 1;
+};
+
+/* Private part of the GdkPixbufFrame structure */
+struct _GdkPixbufFrame {
+ /* The pixbuf with this frame's image data */
+ GdkPixbuf *pixbuf;
+
+ /* Offsets for overlaying onto the animation's area */
+ int x_offset;
+ int y_offset;
+
+ /* Frame duration in ms */
+ int delay_time;
+
+ /* Overlay mode */
+ GdkPixbufFrameAction action;
+};
+
+/* Private part of the GdkPixbufAnimation structure */
+struct _GdkPixbufAnimation {
+ /* Reference count */
+ int ref_count;
+
+ /* Number of frames */
+ int n_frames;
+
+ /* List of GdkPixbufFrame structures */
+ GList *frames;
+
+ /* bounding box size */
+ int width, height;
+};
+
+\f
+
+#endif
-#include "gdk-pixbuf.h"
+/* GdkPixbuf library - Scaling and compositing functions
+ *
+ * Copyright (C) 1999 The Free Software Foundation
+ *
+ * Author: Owen Taylor <otaylor@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <math.h>
+#include "gdk-pixbuf-private.h"
#include "pixops/pixops.h"
-#include "math.h"
+
+\f
/**
* gdk_pixbuf_scale:
* @offset_y: the offset in the Y direction (currently rounded to an integer)
* @scale_x: the scale factor in the X direction
* @scale_y: the scale factor in the Y direction
- * @filter_level: the filter quality for the transformation.
+ * @interp_type: the interpolation type for the transformation.
*
* Transforms the image by source image by scaling by @scale_x and @scale_y then
* translating by @offset_x and @offset_y, then renders the rectangle
double offset_y,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level)
+ GdkInterpType interp_type)
{
+ g_return_if_fail (src != NULL);
+ g_return_if_fail (dest != NULL);
+ g_return_if_fail (dest_x >= 0 && dest_x + dest_width <= dest->width);
+ g_return_if_fail (dest_y >= 0 && dest_y + dest_height <= dest->height);
+
offset_x = floor (offset_x + 0.5);
offset_y = floor (offset_y + 0.5);
- pixops_scale (dest->art_pixbuf->pixels + dest_y * dest->art_pixbuf->rowstride + dest_x * dest->art_pixbuf->n_channels,
+ pixops_scale (dest->pixels + dest_y * dest->rowstride + dest_x * dest->n_channels,
-offset_x, -offset_y, dest_width - offset_x, dest_height - offset_y,
- dest->art_pixbuf->rowstride, dest->art_pixbuf->n_channels, dest->art_pixbuf->has_alpha,
- src->art_pixbuf->pixels, src->art_pixbuf->width, src->art_pixbuf->height,
- src->art_pixbuf->rowstride, src->art_pixbuf->n_channels, src->art_pixbuf->has_alpha,
- scale_x, scale_y, filter_level);
+ dest->rowstride, dest->n_channels, dest->has_alpha,
+ src->pixels, src->width, src->height,
+ src->rowstride, src->n_channels, src->has_alpha,
+ scale_x, scale_y, interp_type);
}
/**
* @offset_y: the offset in the Y direction (currently rounded to an integer)
* @scale_x: the scale factor in the X direction
* @scale_y: the scale factor in the Y direction
- * @filter_level: the filter quality for the transformation.
+ * @interp_type: the interpolation type for the transformation.
* @overall_alpha: overall alpha for source image (0..255)
*
* Transforms the image by source image by scaling by @scale_x and @scale_y then
double offset_y,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha)
{
+ g_return_if_fail (src != NULL);
+ g_return_if_fail (dest != NULL);
+ g_return_if_fail (dest_x >= 0 && dest_x + dest_width <= dest->width);
+ g_return_if_fail (dest_y >= 0 && dest_y + dest_height <= dest->height);
+ g_return_if_fail (overall_alpha >= 0 && overall_alpha <= 255);
+
offset_x = floor (offset_x + 0.5);
offset_y = floor (offset_y + 0.5);
- pixops_composite (dest->art_pixbuf->pixels + dest_y * dest->art_pixbuf->rowstride + dest_x * dest->art_pixbuf->n_channels,
+ pixops_composite (dest->pixels + dest_y * dest->rowstride + dest_x * dest->n_channels,
-offset_x, -offset_y, dest_width - offset_x, dest_height - offset_y,
- dest->art_pixbuf->rowstride, dest->art_pixbuf->n_channels, dest->art_pixbuf->has_alpha,
- src->art_pixbuf->pixels, src->art_pixbuf->width, src->art_pixbuf->height,
- src->art_pixbuf->rowstride, src->art_pixbuf->n_channels, src->art_pixbuf->has_alpha,
- scale_x, scale_y, filter_level, overall_alpha);
+ dest->rowstride, dest->n_channels, dest->has_alpha,
+ src->pixels, src->width, src->height,
+ src->rowstride, src->n_channels, src->has_alpha,
+ scale_x, scale_y, interp_type, overall_alpha);
}
/**
* @offset_y: the offset in the Y direction (currently rounded to an integer)
* @scale_x: the scale factor in the X direction
* @scale_y: the scale factor in the Y direction
- * @filter_level: the filter quality for the transformation.
+ * @interp_type: the interpolation type for the transformation.
* @overall_alpha: overall alpha for source image (0..255)
* @check_x: the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y)
* @check_y: the Y offset for the checkboard
double offset_y,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha,
int check_x,
int check_y,
int check_size,
- art_u32 color1,
- art_u32 color2)
+ guint32 color1,
+ guint32 color2)
{
+ g_return_if_fail (src != NULL);
+ g_return_if_fail (dest != NULL);
+ g_return_if_fail (dest_x >= 0 && dest_x + dest_width <= dest->width);
+ g_return_if_fail (dest_y >= 0 && dest_y + dest_height <= dest->height);
+ g_return_if_fail (overall_alpha >= 0 && overall_alpha <= 255);
+
offset_x = floor (offset_x + 0.5);
offset_y = floor (offset_y + 0.5);
- pixops_composite_color (dest->art_pixbuf->pixels + dest_y * dest->art_pixbuf->rowstride + dest_x * dest->art_pixbuf->n_channels,
+ pixops_composite_color (dest->pixels + dest_y * dest->rowstride + dest_x * dest->n_channels,
-offset_x, -offset_y, dest_width - offset_x, dest_height - offset_y,
- dest->art_pixbuf->rowstride, dest->art_pixbuf->n_channels, dest->art_pixbuf->has_alpha,
- src->art_pixbuf->pixels, src->art_pixbuf->width, src->art_pixbuf->height,
- src->art_pixbuf->rowstride, src->art_pixbuf->n_channels, src->art_pixbuf->has_alpha,
- scale_x, scale_y, filter_level, overall_alpha, check_x, check_y, check_size, color1, color2);
+ dest->rowstride, dest->n_channels, dest->has_alpha,
+ src->pixels, src->width, src->height,
+ src->rowstride, src->n_channels, src->has_alpha,
+ scale_x, scale_y, interp_type, overall_alpha, check_x, check_y,
+ check_size, color1, color2);
}
/**
* @src: a #GdkPixbuf
* @dest_width: the width of destination image
* @dest_height: the height of destination image
- * @filter_level: the filter quality for the transformation.
+ * @interp_type: the interpolation type for the transformation.
*
* Scale the #GdkPixbuf @src to @dest_width x @dest_height and render the result into
* a new #GdkPixbuf.
*
- * Return value: the new #GdkPixbuf
+ * Return value: the new #GdkPixbuf, or NULL if not enough memory could be
+ * allocated for it.
**/
GdkPixbuf *
gdk_pixbuf_scale_simple (const GdkPixbuf *src,
int dest_width,
int dest_height,
- ArtFilterLevel filter_level)
+ GdkInterpType interp_type)
{
- GdkPixbuf *dest = gdk_pixbuf_new (ART_PIX_RGB, src->art_pixbuf->has_alpha, 8, dest_width, dest_height);
+ GdkPixbuf *dest;
+
+ g_return_val_if_fail (src != NULL, NULL);
+ g_return_val_if_fail (dest_width > 0, NULL);
+ g_return_val_if_fail (dest_height > 0, NULL);
+
+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, src->has_alpha, 8, dest_width, dest_height);
+ if (!dest)
+ return NULL;
gdk_pixbuf_scale (src, dest, 0, 0, dest_width, dest_height, 0, 0,
- (double)dest_width / src->art_pixbuf->width,
- (double)dest_height / src->art_pixbuf->height,
- filter_level);
+ (double) dest_width / src->width,
+ (double) dest_height / src->height,
+ interp_type);
return dest;
}
* @src: a #GdkPixbuf
* @dest_width: the width of destination image
* @dest_height: the height of destination image
- * @filter_level: the filter quality for the transformation.
+ * @interp_type: the interpolation type for the transformation.
* @overall_alpha: overall alpha for source image (0..255)
* @check_size: the size of checks in the checkboard (must be a power of two)
* @color1: the color of check at upper left
* a checkboard of colors @color1 and @color2 and render the result into
* a new #GdkPixbuf.
*
- * Return value: the new #GdkPixbuf
+ * Return value: the new #GdkPixbuf, or NULL if not enough memory could be
+ * allocated for it.
**/
GdkPixbuf *
gdk_pixbuf_composite_color_simple (const GdkPixbuf *src,
int dest_width,
int dest_height,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha,
int check_size,
- art_u32 color1,
- art_u32 color2)
+ guint32 color1,
+ guint32 color2)
{
- GdkPixbuf *dest = gdk_pixbuf_new (ART_PIX_RGB, src->art_pixbuf->has_alpha, 8, dest_width, dest_height);
+ GdkPixbuf *dest;
+
+ g_return_val_if_fail (src != NULL, NULL);
+ g_return_val_if_fail (dest_width > 0, NULL);
+ g_return_val_if_fail (dest_height > 0, NULL);
+ g_return_val_if_fail (overall_alpha >= 0 && overall_alpha <= 255, NULL);
+
+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, src->has_alpha, 8, dest_width, dest_height);
+ if (!dest)
+ return NULL;
gdk_pixbuf_composite_color (src, dest, 0, 0, dest_width, dest_height, 0, 0,
- (double)dest_width / src->art_pixbuf->width,
- (double)dest_height / src->art_pixbuf->height,
- filter_level, overall_alpha, 0, 0, check_size, color1, color2);
+ (double) dest_width / src->width,
+ (double) dest_height / src->height,
+ interp_type, overall_alpha, 0, 0, check_size, color1, color2);
return dest;
}
-
-
-
*/
#include <config.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
\f
* Return value: A newly-created pixbuf with a reference count of 1.
**/
GdkPixbuf *
-gdk_pixbuf_add_alpha (GdkPixbuf *pixbuf, gboolean substitute_color, guchar r, guchar g, guchar b)
+gdk_pixbuf_add_alpha (const GdkPixbuf *pixbuf,
+ gboolean substitute_color, guchar r, guchar g, guchar b)
{
- ArtPixBuf *apb;
- ArtPixBuf *new_apb;
GdkPixbuf *new_pixbuf;
int x, y;
g_return_val_if_fail (pixbuf != NULL, NULL);
+ g_return_val_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB, NULL);
+ g_return_val_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4, NULL);
+ g_return_val_if_fail (pixbuf->bits_per_sample == 8, NULL);
- apb = pixbuf->art_pixbuf;
- g_return_val_if_fail (apb->format == ART_PIX_RGB, NULL);
- g_return_val_if_fail (apb->n_channels == 3 || apb->n_channels == 4, NULL);
- g_return_val_if_fail (apb->bits_per_sample == 8, NULL);
-
- if (apb->has_alpha) {
- new_apb = art_pixbuf_duplicate (apb);
- if (!new_apb)
+ if (pixbuf->has_alpha) {
+ new_pixbuf = gdk_pixbuf_copy (pixbuf);
+ if (!new_pixbuf)
return NULL;
- return gdk_pixbuf_new_from_art_pixbuf (new_apb);
+ return new_pixbuf;
}
- new_pixbuf = gdk_pixbuf_new (ART_PIX_RGB, TRUE, 8, apb->width, apb->height);
+ new_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, pixbuf->width, pixbuf->height);
if (!new_pixbuf)
return NULL;
- new_apb = new_pixbuf->art_pixbuf;
-
- for (y = 0; y < apb->height; y++) {
+ for (y = 0; y < pixbuf->height; y++) {
guchar *src, *dest;
guchar tr, tg, tb;
- src = apb->pixels + y * apb->rowstride;
- dest = new_apb->pixels + y * new_apb->rowstride;
+ src = pixbuf->pixels + y * pixbuf->rowstride;
+ dest = new_pixbuf->pixels + y * new_pixbuf->rowstride;
- for (x = 0; x < apb->width; x++) {
+ for (x = 0; x < pixbuf->width; x++) {
tr = *dest++ = *src++;
tg = *dest++ = *src++;
tb = *dest++ = *src++;
GdkPixbuf *dest_pixbuf,
int dest_x, int dest_y)
{
- const ArtPixBuf *src_apb;
- ArtPixBuf *dest_apb;
-
g_return_if_fail (src_pixbuf != NULL);
g_return_if_fail (dest_pixbuf != NULL);
- src_apb = src_pixbuf->art_pixbuf;
- dest_apb = dest_pixbuf->art_pixbuf;
-
- g_return_if_fail (src_x >= 0 && src_x + width <= src_apb->width);
- g_return_if_fail (src_y >= 0 && src_y + height <= src_apb->height);
+ g_return_if_fail (src_x >= 0 && src_x + width <= src_pixbuf->width);
+ g_return_if_fail (src_y >= 0 && src_y + height <= src_pixbuf->height);
- g_return_if_fail (dest_x >= 0 && dest_x + width <= dest_apb->width);
- g_return_if_fail (dest_y >= 0 && dest_y + height <= dest_apb->height);
+ g_return_if_fail (dest_x >= 0 && dest_x + width <= dest_pixbuf->width);
+ g_return_if_fail (dest_y >= 0 && dest_y + height <= dest_pixbuf->height);
/* This will perform format conversions automatically */
(double) (dest_x - src_x),
(double) (dest_y - src_y),
1.0, 1.0,
- ART_FILTER_NEAREST);
+ GDK_INTERP_NEAREST);
}
+/* FIXME FIXME FIXME
+ *
+ * This file is not being used. The gdk_pixbuf_scale() here is not useful
+ * anymore, since we have the new functions in gdk-pixbuf-scale.c.
+ *
+ * The rotation function needs to be implemented without libart if it is
+ * to go inside the GdkPixbuf library.
+ */
+
GdkPixbuf *
gdk_pixbuf_scale (const GdkPixbuf *pixbuf, gint w, gint h)
{
- art_u8 *pixels;
+ guchar *pixels;
gint rowstride;
double affine[6];
ArtAlphaGamma *alphagamma;
affine[1] = affine[2] = affine[4] = affine[5] = 0;
- affine[0] = w / (double)(pixbuf->art_pixbuf->width);
- affine[3] = h / (double)(pixbuf->art_pixbuf->height);
+ affine[0] = w / (double)(pixbuf->width);
+ affine[3] = h / (double)(pixbuf->height);
- /* rowstride = w * pixbuf->art_pixbuf->n_channels; */
+ /* rowstride = w * pixbuf->n_channels; */
rowstride = w * 3;
pixels = art_alloc (h * rowstride);
#include <config.h>
#include <math.h>
-#include <libart_lgpl/art_misc.h>
-#include <libart_lgpl/art_affine.h>
-#include <libart_lgpl/art_pixbuf.h>
-#include <libart_lgpl/art_rgb_pixbuf_affine.h>
-#include <libart_lgpl/art_alphagamma.h>
+#include <stdlib.h>
#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
\f
* gdk_pixbuf_unref:
* @pixbuf: A pixbuf.
*
- * Removes a reference from a pixbuf. It will be destroyed when the reference
+ * Removes a reference from a pixbuf, which will be destroyed when the reference
* count drops to zero.
**/
void
pixbuf->ref_count--;
if (pixbuf->ref_count == 0) {
- art_pixbuf_free (pixbuf->art_pixbuf);
- pixbuf->art_pixbuf = NULL;
+ if (pixbuf->destroy_fn)
+ (* pixbuf->destroy_fn) (pixbuf->pixels, pixbuf->destroy_fn_data);
+
g_free (pixbuf);
}
}
\f
-/* Wrap a libart pixbuf */
-
-/**
- * gdk_pixbuf_new_from_art_pixbuf:
- * @art_pixbuf: A libart pixbuf.
- *
- * Creates a #GdkPixbuf by wrapping a libart pixbuf.
- *
- * Return value: A newly-created #GdkPixbuf structure with a reference count of
- * 1.
- **/
-GdkPixbuf *
-gdk_pixbuf_new_from_art_pixbuf (ArtPixBuf *art_pixbuf)
-{
- GdkPixbuf *pixbuf;
-
- g_return_val_if_fail (art_pixbuf != NULL, NULL);
-
- pixbuf = g_new (GdkPixbuf, 1);
- pixbuf->ref_count = 1;
- pixbuf->art_pixbuf = art_pixbuf;
-
- return pixbuf;
-}
-
-/* Destroy notification function for gdk_pixbuf_new() */
+/* Used as the destroy notification function for gdk_pixbuf_new() */
static void
-free_buffer (gpointer user_data, gpointer data)
+free_buffer (guchar *pixels, gpointer data)
{
- free (data);
+ free (pixels);
}
-\f
-
-/* Create an empty pixbuf */
-
/**
* gdk_pixbuf_new:
- * @format: Image format.
+ * @colorspace: Color space for image.
* @has_alpha: Whether the image should have transparency information.
* @bits_per_sample: Number of bits per color sample.
* @width: Width of image in pixels.
*
* Creates a new #GdkPixbuf structure and allocates a buffer for it. The buffer
* has an optimal rowstride. Note that the buffer is not cleared; you will have
- * to fill it completely.
+ * to fill it completely yourself.
*
* Return value: A newly-created #GdkPixbuf with a reference count of 1, or NULL
* if not enough memory could be allocated for the image buffer.
**/
GdkPixbuf *
-gdk_pixbuf_new (ArtPixFormat format, gboolean has_alpha, int bits_per_sample,
+gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample,
int width, int height)
{
guchar *buf;
int channels;
int rowstride;
- g_return_val_if_fail (format == ART_PIX_RGB, NULL);
+ g_return_val_if_fail (colorspace == GDK_COLORSPACE_RGB, NULL);
g_return_val_if_fail (bits_per_sample == 8, NULL);
g_return_val_if_fail (width > 0, NULL);
g_return_val_if_fail (height > 0, NULL);
if (!buf)
return NULL;
- return gdk_pixbuf_new_from_data (buf, format, has_alpha, width, height, rowstride,
+ return gdk_pixbuf_new_from_data (buf, colorspace, has_alpha, bits_per_sample,
+ width, height, rowstride,
free_buffer, NULL);
}
+/**
+ * gdk_pixbuf_copy:
+ * @pixbuf: A pixbuf.
+ *
+ * Creates a new #GdkPixbuf with a copy of the information in the specified
+ * @pixbuf.
+ *
+ * Return value: A newly-created pixbuf with a reference count of 1, or NULL if
+ * not enough memory could be allocated.
+ **/
+GdkPixbuf *
+gdk_pixbuf_copy (const GdkPixbuf *pixbuf)
+{
+ guchar *buf;
+ int size;
+
+ g_return_val_if_fail (pixbuf != NULL, NULL);
+
+ /* Calculate a semi-exact size. Here we copy with full rowstrides;
+ * maybe we should copy each row individually with the minimum
+ * rowstride?
+ */
+
+ size = ((pixbuf->height - 1) * pixbuf->rowstride +
+ pixbuf->width * ((pixbuf->n_channels * pixbuf->bits_per_sample + 7) / 8));
+
+ buf = malloc (size * sizeof (guchar));
+ if (!buf)
+ return NULL;
+
+ memcpy (buf, pixbuf->pixels, size);
+
+ return gdk_pixbuf_new_from_data (buf,
+ pixbuf->colorspace, pixbuf->has_alpha,
+ pixbuf->bits_per_sample,
+ pixbuf->width, pixbuf->height,
+ pixbuf->rowstride,
+ free_buffer,
+ NULL);
+}
+
\f
-/* Convenience functions */
+/* Accessors */
/**
- * gdk_pixbuf_get_format:
+ * gdk_pixbuf_get_colorspace:
* @pixbuf: A pixbuf.
*
- * Queries the image format (color model) of a pixbuf.
+ * Queries the color space of a pixbuf.
*
- * Return value: Image format.
+ * Return value: Color space.
**/
-ArtPixFormat
-gdk_pixbuf_get_format (GdkPixbuf *pixbuf)
+GdkColorspace
+gdk_pixbuf_get_colorspace (const GdkPixbuf *pixbuf)
{
- g_return_val_if_fail (pixbuf != NULL, ART_PIX_RGB);
- g_assert (pixbuf->art_pixbuf != NULL);
+ g_return_val_if_fail (pixbuf != NULL, GDK_COLORSPACE_RGB);
- return pixbuf->art_pixbuf->format;
+ return pixbuf->colorspace;
}
/**
* Return value: Number of channels.
**/
int
-gdk_pixbuf_get_n_channels (GdkPixbuf *pixbuf)
+gdk_pixbuf_get_n_channels (const GdkPixbuf *pixbuf)
{
g_return_val_if_fail (pixbuf != NULL, -1);
- g_assert (pixbuf->art_pixbuf != NULL);
- return pixbuf->art_pixbuf->n_channels;
+ return pixbuf->n_channels;
}
/**
* Return value: TRUE if it has an alpha channel, FALSE otherwise.
**/
gboolean
-gdk_pixbuf_get_has_alpha (GdkPixbuf *pixbuf)
+gdk_pixbuf_get_has_alpha (const GdkPixbuf *pixbuf)
{
g_return_val_if_fail (pixbuf != NULL, -1);
- g_assert (pixbuf->art_pixbuf != NULL);
- return pixbuf->art_pixbuf->has_alpha;
+ return pixbuf->has_alpha ? TRUE : FALSE;
}
/**
* Return value: Number of bits per color sample.
**/
int
-gdk_pixbuf_get_bits_per_sample (GdkPixbuf *pixbuf)
+gdk_pixbuf_get_bits_per_sample (const GdkPixbuf *pixbuf)
{
g_return_val_if_fail (pixbuf != NULL, -1);
- g_assert (pixbuf->art_pixbuf != NULL);
- return pixbuf->art_pixbuf->bits_per_sample;
+ return pixbuf->bits_per_sample;
}
/**
* Return value: A pointer to the pixbuf's pixel data.
**/
guchar *
-gdk_pixbuf_get_pixels (GdkPixbuf *pixbuf)
+gdk_pixbuf_get_pixels (const GdkPixbuf *pixbuf)
{
g_return_val_if_fail (pixbuf != NULL, NULL);
- g_assert (pixbuf->art_pixbuf != NULL);
- return pixbuf->art_pixbuf->pixels;
+ return pixbuf->pixels;
}
/**
* Return value: Width in pixels.
**/
int
-gdk_pixbuf_get_width (GdkPixbuf *pixbuf)
+gdk_pixbuf_get_width (const GdkPixbuf *pixbuf)
{
g_return_val_if_fail (pixbuf != NULL, -1);
- g_assert (pixbuf->art_pixbuf != NULL);
- return pixbuf->art_pixbuf->width;
+ return pixbuf->width;
}
/**
* Return value: Height in pixels.
**/
int
-gdk_pixbuf_get_height (GdkPixbuf *pixbuf)
+gdk_pixbuf_get_height (const GdkPixbuf *pixbuf)
{
g_return_val_if_fail (pixbuf != NULL, -1);
- g_assert (pixbuf->art_pixbuf != NULL);
- return pixbuf->art_pixbuf->height;
+ return pixbuf->height;
}
/**
* gdk_pixbuf_get_rowstride:
* @pixbuf: A pixbuf.
*
- * Queries the rowstride of a pixbuf, or the number of bytes between rows.
+ * Queries the rowstride of a pixbuf, which is the number of bytes between rows.
*
* Return value: Number of bytes between rows.
**/
int
-gdk_pixbuf_get_rowstride (GdkPixbuf *pixbuf)
+gdk_pixbuf_get_rowstride (const GdkPixbuf *pixbuf)
{
g_return_val_if_fail (pixbuf != NULL, -1);
- g_assert (pixbuf->art_pixbuf != NULL);
- return pixbuf->art_pixbuf->rowstride;
+ return pixbuf->rowstride;
}
\f
/* General initialization hooks */
-const guint gdk_pixbuf_major_version=GDK_PIXBUF_MAJOR,
- gdk_pixbuf_minor_version=GDK_PIXBUF_MINOR,
- gdk_pixbuf_micro_version=GDK_PIXBUF_MICRO;
+const guint gdk_pixbuf_major_version = GDK_PIXBUF_MAJOR;
+const guint gdk_pixbuf_minor_version = GDK_PIXBUF_MINOR;
+const guint gdk_pixbuf_micro_version = GDK_PIXBUF_MICRO;
const char *gdk_pixbuf_version = GDK_PIXBUF_VERSION;
void
-gdk_pixbuf_preinit(gpointer app, gpointer modinfo)
+gdk_pixbuf_preinit (gpointer app, gpointer modinfo)
{
}
void
-gdk_pixbuf_postinit(gpointer app, gpointer modinfo)
+gdk_pixbuf_postinit (gpointer app, gpointer modinfo)
{
}
* Authors: Mark Crichton <crichton@gimp.org>
* Miguel de Icaza <miguel@gnu.org>
* Federico Mena-Quintero <federico@gimp.org>
+ * Havoc Pennington <hp@redhat.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
#ifndef GDK_PIXBUF_H
#define GDK_PIXBUF_H
-#include <libart_lgpl/art_misc.h>
-#include <libart_lgpl/art_pixbuf.h>
-#include <libart_lgpl/art_filterlevel.h>
#include <gdk/gdk.h>
#ifdef __cplusplus
#include <gdk-pixbuf/gdk-pixbuf-features.h>
-/* GdkPixbuf structures */
-typedef struct _GdkPixbuf GdkPixbuf;
-typedef struct _GdkPixbufFrame GdkPixbufFrame;
-typedef struct _GdkPixbufAnimation GdkPixbufAnimation;
-
-struct _GdkPixbuf {
- /* Reference count */
- int ref_count;
-
- /* Libart pixbuf */
- ArtPixBuf *art_pixbuf;
-};
+\f
-/* GIF-like animation overlay modes for frames */
+/* Color spaces; right now only RGB is supported */
typedef enum {
- GDK_PIXBUF_FRAME_RETAIN,
- GDK_PIXBUF_FRAME_DISPOSE,
- GDK_PIXBUF_FRAME_REVERT
-} GdkPixbufFrameAction;
-
-struct _GdkPixbufFrame {
- /* The pixbuf with this frame's image data */
- GdkPixbuf *pixbuf;
-
- /* Offsets for overlaying onto the animation's area */
- int x_offset;
- int y_offset;
-
- /* Frame duration in ms */
- int delay_time;
-
- /* Overlay mode */
- GdkPixbufFrameAction action;
-};
-
-struct _GdkPixbufAnimation {
- /* Reference count */
- int ref_count;
+ GDK_COLORSPACE_RGB
+} GdkColorspace;
- /* Number of frames */
- int n_frames;
-
- /* List of GdkPixbufFrame structures */
- GList *frames;
+/* All of these are opaque structures */
+typedef struct _GdkPixbuf GdkPixbuf;
+typedef struct _GdkPixbufFrame GdkPixbufFrame;
+typedef struct _GdkPixbufAnimation GdkPixbufAnimation;
- /* bounding box size */
- int width, height;
-};
+typedef void (* GdkPixbufDestroyNotify) (guchar *pixels, gpointer data);
\f
-/* Convenience functions */
-
-ArtPixFormat gdk_pixbuf_get_format (GdkPixbuf *pixbuf);
-int gdk_pixbuf_get_n_channels (GdkPixbuf *pixbuf);
-gboolean gdk_pixbuf_get_has_alpha (GdkPixbuf *pixbuf);
-int gdk_pixbuf_get_bits_per_sample (GdkPixbuf *pixbuf);
-guchar *gdk_pixbuf_get_pixels (GdkPixbuf *pixbuf);
-int gdk_pixbuf_get_width (GdkPixbuf *pixbuf);
-int gdk_pixbuf_get_height (GdkPixbuf *pixbuf);
-int gdk_pixbuf_get_rowstride (GdkPixbuf *pixbuf);
-
/* Reference counting */
GdkPixbuf *gdk_pixbuf_ref (GdkPixbuf *pixbuf);
void gdk_pixbuf_unref (GdkPixbuf *pixbuf);
-/* Wrap a libart pixbuf */
-GdkPixbuf *gdk_pixbuf_new_from_art_pixbuf (ArtPixBuf *art_pixbuf);
+/* GdkPixbuf accessors */
+
+GdkColorspace gdk_pixbuf_get_colorspace (const GdkPixbuf *pixbuf);
+int gdk_pixbuf_get_n_channels (const GdkPixbuf *pixbuf);
+gboolean gdk_pixbuf_get_has_alpha (const GdkPixbuf *pixbuf);
+int gdk_pixbuf_get_bits_per_sample (const GdkPixbuf *pixbuf);
+guchar *gdk_pixbuf_get_pixels (const GdkPixbuf *pixbuf);
+int gdk_pixbuf_get_width (const GdkPixbuf *pixbuf);
+int gdk_pixbuf_get_height (const GdkPixbuf *pixbuf);
+int gdk_pixbuf_get_rowstride (const GdkPixbuf *pixbuf);
+
+\f
/* Create a blank pixbuf with an optimal rowstride and a new buffer */
-GdkPixbuf *gdk_pixbuf_new (ArtPixFormat format, gboolean has_alpha, int bits_per_sample,
+GdkPixbuf *gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample,
int width, int height);
+/* Copy a pixbuf */
+
+GdkPixbuf *gdk_pixbuf_copy (const GdkPixbuf *pixbuf);
+
/* Simple loading */
GdkPixbuf *gdk_pixbuf_new_from_file (const char *filename);
GdkPixbuf *gdk_pixbuf_new_from_data (const guchar *data,
- ArtPixFormat format,
+ GdkColorspace colorspace,
gboolean has_alpha,
+ int bits_per_sample,
int width, int height,
int rowstride,
- ArtDestroyNotify dfunc,
- gpointer dfunc_data);
+ GdkPixbufDestroyNotify destroy_fn,
+ gpointer destroy_fn_data);
GdkPixbuf *gdk_pixbuf_new_from_xpm_data (const char **data);
/* Adding an alpha channel */
-GdkPixbuf *gdk_pixbuf_add_alpha (GdkPixbuf *pixbuf, gboolean substitute_color,
+GdkPixbuf *gdk_pixbuf_add_alpha (const GdkPixbuf *pixbuf, gboolean substitute_color,
guchar r, guchar g, guchar b);
+/* Copy an area of a pixbuf onto another one */
+void gdk_pixbuf_copy_area (const GdkPixbuf *src_pixbuf,
+ int src_x, int src_y,
+ int width, int height,
+ GdkPixbuf *dest_pixbuf,
+ int dest_x, int dest_y);
+
+\f
+
/* Rendering to a drawable */
/* Alpha compositing mode */
GdkRgbDither dither,
int x_dither, int y_dither);
-void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf,
- GdkPixmap **pixmap_return, GdkBitmap **mask_return,
- int alpha_threshold);
+void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf,
+ GdkPixmap **pixmap_return, GdkBitmap **mask_return,
+ int alpha_threshold);
/* Fetching a region from a drawable */
-GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf *dest,
- GdkDrawable *src, GdkColormap *cmap,
- int src_x, int src_y,
- int dest_x, int dest_y,
- int width, int height);
+GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf *dest,
+ GdkDrawable *src, GdkColormap *cmap,
+ int src_x, int src_y,
+ int dest_x, int dest_y,
+ int width, int height);
-/* Copy an area of a pixbuf onto another one */
-void gdk_pixbuf_copy_area (const GdkPixbuf *src_pixbuf,
- int src_x, int src_y,
- int width, int height,
- GdkPixbuf *dest_pixbuf,
- int dest_x, int dest_y);
+\f
/* Scaling */
+/* Interpolation modes */
+typedef enum {
+ GDK_INTERP_NEAREST,
+ GDK_INTERP_TILES,
+ GDK_INTERP_BILINEAR,
+ GDK_INTERP_HYPER
+} GdkInterpType;
+
void gdk_pixbuf_scale (const GdkPixbuf *src,
GdkPixbuf *dest,
int dest_x,
double offset_y,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level);
+ GdkInterpType interp_type);
void gdk_pixbuf_composite (const GdkPixbuf *src,
GdkPixbuf *dest,
int dest_x,
double offset_y,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha);
void gdk_pixbuf_composite_color (const GdkPixbuf *src,
GdkPixbuf *dest,
double offset_y,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha,
int check_x,
int check_y,
int check_size,
- art_u32 color1,
- art_u32 color2);
+ guint32 color1,
+ guint32 color2);
GdkPixbuf *gdk_pixbuf_scale_simple (const GdkPixbuf *src,
int dest_width,
int dest_height,
- ArtFilterLevel filter_level);
+ GdkInterpType interp_type);
+
GdkPixbuf *gdk_pixbuf_composite_color_simple (const GdkPixbuf *src,
int dest_width,
int dest_height,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha,
int check_size,
- art_u32 color1,
- art_u32 color2);
+ guint32 color1,
+ guint32 color2);
+
+\f
/* Animation support */
+/* GIF-like animation overlay modes for frames */
+typedef enum {
+ GDK_PIXBUF_FRAME_RETAIN,
+ GDK_PIXBUF_FRAME_DISPOSE,
+ GDK_PIXBUF_FRAME_REVERT
+} GdkPixbufFrameAction;
+
GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file (const char *filename);
GdkPixbufAnimation *gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation);
GList *gdk_pixbuf_animation_get_frames (GdkPixbufAnimation *animation);
int gdk_pixbuf_animation_get_num_frames (GdkPixbufAnimation *animation);
+/* Frame accessors */
+
+GdkPixbuf *gdk_pixbuf_frame_get_pixbuf (GdkPixbufFrame *frame);
+int gdk_pixbuf_frame_get_x_offset (GdkPixbufFrame *frame);
+int gdk_pixbuf_frame_get_y_offset (GdkPixbufFrame *frame);
+int gdk_pixbuf_frame_get_delay_time (GdkPixbufFrame *frame);
+GdkPixbufFrameAction gdk_pixbuf_frame_get_action (GdkPixbufFrame *frame);
+
+
/* General (presently empty) initialization hooks, primarily for gnome-libs */
void gdk_pixbuf_preinit (gpointer app, gpointer modinfo);
void gdk_pixbuf_postinit (gpointer app, gpointer modinfo);
#include <math.h>
#include <libgnomeui/gnome-canvas.h>
#include <libgnomeui/gnome-canvas-util.h>
-#include "gdk-pixbuf.h"
-#include <libart_lgpl/art_rgb_pixbuf_affine.h>
+#include <libart_lgpl/art_rgb_affine.h>
+#include <libart_lgpl/art_rgb_rgba_affine.h>
+#include "gdk-pixbuf-private.h"
#include "gnome-canvas-pixbuf.h"
\f
pixbuf = GTK_VALUE_POINTER (*arg);
if (pixbuf != priv->pixbuf) {
if (pixbuf) {
- g_return_if_fail (pixbuf->art_pixbuf->format == ART_PIX_RGB);
- g_return_if_fail (pixbuf->art_pixbuf->n_channels == 3
- || pixbuf->art_pixbuf->n_channels == 4);
- g_return_if_fail (pixbuf->art_pixbuf->bits_per_sample == 8);
+ g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
+ g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4);
+ g_return_if_fail (pixbuf->bits_per_sample == 8);
gdk_pixbuf_ref (pixbuf);
}
if (priv->width_set)
w = priv->width;
else
- w = priv->pixbuf->art_pixbuf->width;
+ w = priv->pixbuf->width;
if (priv->height_set)
h = priv->height;
else
- h = priv->pixbuf->art_pixbuf->height;
+ h = priv->pixbuf->height;
/* Convert i_len and j_len into scaling factors */
} else
si_len = 1.0;
- si_len *= w / priv->pixbuf->art_pixbuf->width;
+ si_len *= w / priv->pixbuf->width;
if (priv->height_in_pixels) {
if (j_len > GNOME_CANVAS_EPSILON)
} else
sj_len = 1.0;
- sj_len *= h / priv->pixbuf->art_pixbuf->height;
+ sj_len *= h / priv->pixbuf->height;
/* Calculate translation offsets */
}
rect.x0 = 0.0;
- rect.x1 = priv->pixbuf->art_pixbuf->width;
+ rect.x1 = priv->pixbuf->width;
rect.y0 = 0.0;
- rect.y1 = priv->pixbuf->art_pixbuf->height;
+ rect.y1 = priv->pixbuf->height;
gnome_canvas_item_i2c_affine (item, i2c);
compute_render_affine (gcp, render_affine, i2c);
transform_pixbuf (guchar *dest, int x, int y, int width, int height, int rowstride,
GdkPixbuf *pixbuf, double *affine)
{
- ArtPixBuf *apb;
int xx, yy;
double inv[6];
guchar *src, *d;
int src_x, src_y;
int i;
- apb = pixbuf->art_pixbuf;
-
art_affine_invert (inv, affine);
for (yy = 0; yy < height; yy++) {
run_x1 = x;
run_x2 = x + width;
art_rgb_affine_run (&run_x1, &run_x2, yy + y,
- apb->width, apb->height,
+ pixbuf->width, pixbuf->height,
inv);
d = dest + yy * rowstride + (run_x1 - x) * 4;
src_x = floor (src_p.x);
src_y = floor (src_p.y);
- src = apb->pixels + src_y * apb->rowstride + src_x * apb->n_channels;
+ src = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * pixbuf->n_channels;
- for (i = 0; i < apb->n_channels; i++)
+ for (i = 0; i < pixbuf->n_channels; i++)
*d++ = *src++;
- if (!apb->has_alpha)
+ if (!pixbuf->has_alpha)
*d++ = 255; /* opaque */
}
}
w * 4,
priv->pixbuf, render_affine);
- pixbuf = gdk_pixbuf_new_from_data (buf, ART_PIX_RGB, TRUE, w, h, w * 4, NULL, NULL);
+ pixbuf = gdk_pixbuf_new_from_data (buf, GDK_COLORSPACE_RGB, TRUE, 8, w, h, w * 4, NULL, NULL);
gdk_pixbuf_render_to_drawable_alpha (pixbuf, drawable,
0, 0,
compute_render_affine (gcp, render_affine, i2c);
gnome_canvas_buf_ensure_buf (buf);
- art_rgb_pixbuf_affine (buf->buf,
- buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1,
- buf->buf_rowstride,
- priv->pixbuf->art_pixbuf,
- render_affine,
- ART_FILTER_NEAREST, NULL);
-
- buf->is_bg = 0;
+ if (priv->pixbuf->has_alpha)
+ art_rgb_rgba_affine (buf->buf,
+ buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1,
+ buf->buf_rowstride,
+ priv->pixbuf->pixels,
+ priv->pixbuf->width, priv->pixbuf->height,
+ priv->pixbuf->rowstride,
+ render_affine,
+ ART_FILTER_NEAREST,
+ NULL);
+ else
+ art_rgb_affine (buf->buf,
+ buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1,
+ buf->buf_rowstride,
+ priv->pixbuf->pixels,
+ priv->pixbuf->width, priv->pixbuf->height,
+ priv->pixbuf->rowstride,
+ render_affine,
+ ART_FILTER_NEAREST,
+ NULL);
+
+ buf->is_bg = FALSE;
}
\f
ArtPoint c, p;
int px, py;
double no_hit;
- ArtPixBuf *apb;
guchar *src;
gcp = GNOME_CANVAS_PIXBUF (item);
if (!priv->pixbuf)
return no_hit;
- apb = priv->pixbuf->art_pixbuf;
-
gnome_canvas_item_i2c_affine (item, i2c);
compute_render_affine (gcp, render_affine, i2c);
art_affine_invert (inv, render_affine);
px = p.x;
py = p.y;
- if (px < 0 || px >= apb->width || py < 0 || py >= apb->height)
+ if (px < 0 || px >= priv->pixbuf->width || py < 0 || py >= priv->pixbuf->height)
return no_hit;
- if (!apb->has_alpha)
+ if (!priv->pixbuf->has_alpha)
return 0.0;
- src = apb->pixels + py * apb->rowstride + px * apb->n_channels;
+ src = priv->pixbuf->pixels + py * priv->pixbuf->rowstride + px * priv->pixbuf->n_channels;
if (src[3] < 128)
return no_hit;
}
rect.x0 = 0.0;
- rect.x1 = priv->pixbuf->art_pixbuf->width;
+ rect.x1 = priv->pixbuf->width;
rect.y0 = 0.0;
- rect.y1 = priv->pixbuf->art_pixbuf->height;
+ rect.y1 = priv->pixbuf->height;
gnome_canvas_item_i2c_affine (item, i2c);
compute_viewport_affine (gcp, viewport_affine, i2c);
#include <stdio.h>
#include <unistd.h>
#include <string.h>
-#include <gdk-pixbuf/gdk-pixbuf.h>
-#include <gdk-pixbuf/gdk-pixbuf-io.h>
-\f
-
-
+#include "gdk-pixbuf-private.h"
+#include "gdk-pixbuf-io.h"
+\f
/*
if (State->pixbuf == NULL) {
if (State->Type == 32)
State->pixbuf =
- gdk_pixbuf_new(ART_PIX_RGB, TRUE, 8,
+ gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8,
(gint) State->Header.width,
(gint) State->Header.height);
else
State->pixbuf =
- gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
+ gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
(gint) State->Header.width,
(gint) State->Header.height);
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels =
- context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
Pixels[X * 4 + 0] = context->LineBuf[X * 4 + 2];
Pixels[X * 4 + 1] = context->LineBuf[X * 4 + 1];
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels =
- context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
Pixels[X * 3 + 0] = context->LineBuf[X * 3 + 2];
Pixels[X * 3 + 1] = context->LineBuf[X * 3 + 1];
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels =
- context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
Pixels[X * 3 + 0] =
context->HeaderBuf[4 * context->LineBuf[X] + 56];
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels =
- context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
guchar Pix;
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels =
- context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
gint Bit;
#include <config.h>
#include <stdio.h>
#include <string.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
\f
gint v;
if (context->pixbuf == NULL) {
- context->pixbuf = gdk_pixbuf_new (ART_PIX_RGB,
+ context->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
context->gif89.transparent != -1,
8,
context->frame_len,
#include <stdio.h>
#include <unistd.h>
#include <string.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
-\f
-
+\f
/*
if (State->pixbuf == NULL) {
State->pixbuf =
- gdk_pixbuf_new(ART_PIX_RGB, TRUE, 8,
+ gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8,
(gint) State->Header.width,
(gint) State->Header.height);
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
Pixels[X * 4 + 0] = context->LineBuf[X * 3 + 2];
Pixels[X * 4 + 1] = context->LineBuf[X * 3 + 1];
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
/* The joys of having a BGR byteorder */
Pixels[X * 4 + 0] =
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
guchar Pix;
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Header.height - context->Lines - 1));
else
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- context->Lines;
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ context->Lines);
while (X < context->Header.width) {
int Bit;
X = 0;
if (context->Header.Negative == 0)
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (2*context->Header.height - context->Lines - 1);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (2*context->Header.height - context->Lines - 1));
else
- Pixels = context->pixbuf->art_pixbuf->pixels +
- gdk_pixbuf_get_rowstride(context->pixbuf) *
- (context->Lines-context->Header.height);
+ Pixels = (context->pixbuf->pixels +
+ context->pixbuf->rowstride *
+ (context->Lines-context->Header.height));
while (X < context->Header.width) {
int Bit;
#include <string.h>
#include <setjmp.h>
#include <jpeglib.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
\f
return;
}
-/* Destroy notification function for the libart pixbuf */
+/* Destroy notification function for the pixbuf */
static void
-free_buffer (gpointer user_data, gpointer data)
+free_buffer (guchar *pixels, gpointer data)
{
- free (data);
+ free (pixels);
}
jpeg_finish_decompress (&cinfo);
jpeg_destroy_decompress (&cinfo);
- return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, FALSE,
+ return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, FALSE, 8,
w, h, w * 3,
free_buffer, NULL);
}
return FALSE;
}
#endif
- context->pixbuf = gdk_pixbuf_new(ART_PIX_RGB,
- /*have_alpha*/ FALSE,
+ context->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
+ FALSE,
8,
cinfo->image_width,
cinfo->image_height);
}
/* Use pixbuf buffer to store decompressed data */
- context->dptr = context->pixbuf->art_pixbuf->pixels;
+ context->dptr = context->pixbuf->pixels;
/* Notify the client that we are ready to go */
(* context->prepared_func) (context->pixbuf,
rowptr = context->dptr;
for (i=0; i < cinfo->rec_outbuf_height; i++) {
*lptr++ = rowptr;
- rowptr += context->pixbuf->art_pixbuf->rowstride;
+ rowptr += context->pixbuf->rowstride;
}
nlines = jpeg_read_scanlines (cinfo, lines,
if (cinfo->output_components == 1)
explode_gray_into_buf (cinfo, lines);
- context->dptr += nlines * context->pixbuf->art_pixbuf->rowstride;
+ context->dptr += nlines * context->pixbuf->rowstride;
/* send updated signal */
(* context->updated_func) (context->pixbuf,
#include <config.h>
#include <stdio.h>
+#include <stdlib.h>
#include <png.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
\f
#endif
}
-/* Destroy notification function for the libart pixbuf */
+/* Destroy notification function for the pixbuf */
static void
-free_buffer (gpointer user_data, gpointer data)
+free_buffer (guchar *pixels, gpointer data)
{
- free (data);
+ free (pixels);
}
/* Shared library entry point */
g_free (rows);
if (ctype & PNG_COLOR_MASK_ALPHA)
- return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, TRUE,
+ return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8,
w, h, w * 4,
free_buffer, NULL);
else
- return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, FALSE,
+ return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, FALSE, 8,
w, h, w * 3,
free_buffer, NULL);
}
/* start and end row were in the same pass */
(lc->update_func)(lc->pixbuf, 0,
lc->first_row_seen_in_chunk,
- lc->pixbuf->art_pixbuf->width,
+ lc->pixbuf->width,
(lc->last_row_seen_in_chunk -
lc->first_row_seen_in_chunk) + 1,
lc->notify_user_data);
/* first row to end */
(lc->update_func)(lc->pixbuf, 0,
lc->first_row_seen_in_chunk,
- lc->pixbuf->art_pixbuf->width,
+ lc->pixbuf->width,
(lc->max_row_seen_in_chunk -
lc->first_row_seen_in_chunk) + 1,
lc->notify_user_data);
/* top to last row */
(lc->update_func)(lc->pixbuf,
0, 0,
- lc->pixbuf->art_pixbuf->width,
+ lc->pixbuf->width,
lc->last_row_seen_in_chunk + 1,
lc->notify_user_data);
} else {
whole image */
(lc->update_func)(lc->pixbuf,
0, 0,
- lc->pixbuf->art_pixbuf->width,
+ lc->pixbuf->width,
lc->max_row_seen_in_chunk + 1,
lc->notify_user_data);
}
if (color_type & PNG_COLOR_MASK_ALPHA)
have_alpha = TRUE;
- lc->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, have_alpha, 8, width, height);
+ lc->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, have_alpha, 8, width, height);
if (lc->pixbuf == NULL) {
/* Failed to allocate memory */
lc->last_row_seen_in_chunk = row_num;
lc->last_pass_seen_in_chunk = pass_num;
- old_row = lc->pixbuf->art_pixbuf->pixels + (row_num * lc->pixbuf->art_pixbuf->rowstride);
+ old_row = lc->pixbuf->pixels + (row_num * lc->pixbuf->rowstride);
png_progressive_combine_row(lc->png_read_ptr, old_row, new_row);
}
fprintf(stderr, "Warning loading PNG: %s\n", warning_msg);
}
-
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
\f
static void explode_bitmap_into_buf (PnmLoaderContext *context);
static void explode_gray_into_buf (PnmLoaderContext *context);
-/* Destroy notification function for the libart pixbuf */
+/* Destroy notification function for the pixbuf */
static void
-free_buffer (gpointer user_data, gpointer data)
+free_buffer (guchar *pixels, gpointer data)
{
- free (data);
+ free (pixels);
}
break;
}
- return gdk_pixbuf_new_from_data (context.pixels, ART_PIX_RGB, FALSE,
+ return gdk_pixbuf_new_from_data (context.pixels, GDK_COLORSPACE_RGB, FALSE, 8,
context.width, context.height,
context.width * 3, free_buffer, NULL);
context->output_row = 0;
context->output_col = 0;
- context->pixbuf = gdk_pixbuf_new(ART_PIX_RGB,
- /*have_alpha*/ FALSE,
+ context->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
+ FALSE,
8,
context->width,
context->height);
g_error ("Couldn't allocate gdkpixbuf");
}
- context->pixels = context->pixbuf->art_pixbuf->pixels;
- context->rowstride = context->pixbuf->art_pixbuf->rowstride;
+ context->pixels = context->pixbuf->pixels;
+ context->rowstride = context->pixbuf->rowstride;
/* Notify the client that we are ready to go */
(* context->prepared_func) (context->pixbuf,
#include <stdio.h>
#include <unistd.h>
#include <string.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
\f
-
/*
Header structure for sunras files.
All values are in big-endian order on disk
if (State->pixbuf == NULL) {
if (State->RasType == 32)
- State->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, TRUE,
+ State->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE,
8,
(gint)
State->Header.width,
height);
else
State->pixbuf =
- gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
+ gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
(gint) State->Header.width,
(gint) State->Header.height);
if (State->prepared_func != NULL)
guchar *Pixels;
X = 0;
- Pixels = context->pixbuf->art_pixbuf->pixels +
- context->pixbuf->art_pixbuf->rowstride * context->Lines;
+ Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
while (X < context->Header.width) {
/* The joys of having a BGR byteorder */
Pixels[X * 4 + 0] = context->LineBuf[X * 4 + 2];
guchar *Pixels;
X = 0;
- Pixels = context->pixbuf->art_pixbuf->pixels +
- context->pixbuf->art_pixbuf->rowstride * context->Lines;
+ Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
while (X < context->Header.width) {
/* The joys of having a BGR byteorder */
Pixels[X * 3 + 0] = context->LineBuf[X * 3 + 2];
guchar *Pixels;
X = 0;
- Pixels = context->pixbuf->art_pixbuf->pixels +
- context->pixbuf->art_pixbuf->rowstride * context->Lines;
+ Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
while (X < context->Header.width) {
/* The joys of having a BGR byteorder */
Pixels[X * 3 + 0] =
guchar *Pixels;
X = 0;
- Pixels = context->pixbuf->art_pixbuf->pixels +
- context->pixbuf->art_pixbuf->rowstride * context->Lines;
+ Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines;
while (X < context->Header.width) {
int Bit;
#include <string.h>
#include <unistd.h>
#include <tiffio.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
\f
TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &w);
TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &h);
num_pixs = w * h;
- pixbuf = gdk_pixbuf_new (ART_PIX_RGB, TRUE, 8, w, h);
+ pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, w, h);
if (context)
(* context->prepare_func) (pixbuf, context->user_data);
#include <config.h>
#include <stdio.h>
+#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <gdk/gdk.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
\f
return NULL;
}
-/* Destroy notification function for the libart pixbuf */
+/* Destroy notification function for the pixbuf */
static void
-free_buffer (gpointer user_data, gpointer data)
+free_buffer (guchar *pixels, gpointer data)
{
- free (data);
+ free (pixels);
}
/* This function does all the work. */
g_free (colors);
g_free (name_buf);
- return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, is_trans,
+ return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, is_trans, 8,
w, h, is_trans ? (w * 4) : (w * 3),
free_buffer, NULL);
}
noinst_LTLIBRARIES = libpixops.la
-INCLUDES = $(GLIB_CFLAGS) $(LIBART_CFLAGS)
+INCLUDES = $(GLIB_CFLAGS) $(LIBART_CFLAGS) -I$(top_srcdir)/gdk-pixbuf
noinst_PROGRAMS = timescale
#ifdef USE_MMX
-art_u8 *pixops_scale_line_22_33_mmx (art_u32 weights[16][8], art_u8 *p, art_u8 *q1, art_u8 *q2, int x_step, art_u8 *p_stop, int x_init);
-art_u8 *pixops_composite_line_22_4a4_mmx (art_u32 weights[16][8], art_u8 *p, art_u8 *q1, art_u8 *q2, int x_step, art_u8 *p_stop, int x_init);
-art_u8 *pixops_composite_line_color_22_4a4_mmx (art_u32 weights[16][8], art_u8 *p, art_u8 *q1, art_u8 *q2, int x_step, art_u8 *p_stop, int x_init, int dest_x, int check_shift, int *colors);
+guchar *pixops_scale_line_22_33_mmx (guint32 weights[16][8], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init);
+guchar *pixops_composite_line_22_4a4_mmx (guint32 weights[16][8], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init);
+guchar *pixops_composite_line_color_22_4a4_mmx (guint32 weights[16][8], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init, int dest_x, int check_shift, int *colors);
int pixops_have_mmx (void);
#endif
double y_offset;
};
-typedef art_u8 *(*PixopsLineFunc) (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+typedef guchar *(*PixopsLineFunc) (int *weights, int n_x, int n_y,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2);
+ int check_size, guint32 color1, guint32 color2);
-typedef void (*PixopsPixelFunc) (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha,
- int src_has_alpha, int check_size, art_u32 color1,
- art_u32 color2,
+typedef void (*PixopsPixelFunc) (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha,
+ int src_has_alpha, int check_size, guint32 color1,
+ guint32 color2,
int r, int g, int b, int a);
static int
}
static void
-pixops_scale_nearest (art_u8 *dest_buf,
+pixops_scale_nearest (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int render_y1,
int dest_rowstride,
int dest_channels,
- art_boolean dest_has_alpha,
- const art_u8 *src_buf,
+ gboolean dest_has_alpha,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_channels,
- art_boolean src_has_alpha,
+ gboolean src_has_alpha,
double scale_x,
double scale_y)
{
#define INNER_LOOP(SRC_CHANNELS,DEST_CHANNELS) \
for (j=0; j < (render_x1 - render_x0); j++) \
{ \
- const art_u8 *p = src + (x >> SCALE_SHIFT) * SRC_CHANNELS; \
+ const guchar *p = src + (x >> SCALE_SHIFT) * SRC_CHANNELS; \
\
dest[0] = p[0]; \
dest[1] = p[1]; \
for (i = 0; i < (render_y1 - render_y0); i++)
{
- const art_u8 *src = src_buf + ((i * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride;
- art_u8 *dest = dest_buf + i * dest_rowstride;
+ const guchar *src = src_buf + ((i * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride;
+ guchar *dest = dest_buf + i * dest_rowstride;
x = render_x0 * x_step + x_step / 2;
{
for (j=0; j < (render_x1 - render_x0); j++)
{
- const art_u8 *p = src + (x >> SCALE_SHIFT) * 4;
+ const guchar *p = src + (x >> SCALE_SHIFT) * 4;
+ guint32 *p32;
+
+ p32 = (guint32 *) dest;
+ *p32 = *((guint32 *) p);
- *(art_u32 *)dest = *(art_u32 *)p;
-
dest += 4;
x += x_step;
}
}
}
}
-#undef INNER_LOOP
+#undef INNER_LOOP
}
static void
-pixops_composite_nearest (art_u8 *dest_buf,
+pixops_composite_nearest (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int render_y1,
int dest_rowstride,
int dest_channels,
- art_boolean dest_has_alpha,
- const art_u8 *src_buf,
+ gboolean dest_has_alpha,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_channels,
- art_boolean src_has_alpha,
+ gboolean src_has_alpha,
double scale_x,
double scale_y,
int overall_alpha)
for (i = 0; i < (render_y1 - render_y0); i++)
{
- const art_u8 *src = src_buf + (((i + render_y0) * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride;
- art_u8 *dest = dest_buf + i * dest_rowstride + render_x0 * dest_channels;
+ const guchar *src = src_buf + (((i + render_y0) * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride;
+ guchar *dest = dest_buf + i * dest_rowstride + render_x0 * dest_channels;
x = render_x0 * x_step + x_step / 2;
for (j=0; j < (render_x1 - render_x0); j++)
{
- const art_u8 *p = src + (x >> SCALE_SHIFT) * src_channels;
+ const guchar *p = src + (x >> SCALE_SHIFT) * src_channels;
unsigned int a0;
if (src_has_alpha)
}
static void
-pixops_composite_color_nearest (art_u8 *dest_buf,
+pixops_composite_color_nearest (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int render_y1,
int dest_rowstride,
int dest_channels,
- art_boolean dest_has_alpha,
- const art_u8 *src_buf,
+ gboolean dest_has_alpha,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_channels,
- art_boolean src_has_alpha,
+ gboolean src_has_alpha,
double scale_x,
double scale_y,
int overall_alpha,
int check_x,
int check_y,
int check_size,
- art_u32 color1,
- art_u32 color2)
+ guint32 color1,
+ guint32 color2)
{
int i, j;
int x;
for (i = 0; i < (render_y1 - render_y0); i++)
{
- const art_u8 *src = src_buf + (((i + render_y0) * y_step + y_step/2) >> SCALE_SHIFT) * src_rowstride;
- art_u8 *dest = dest_buf + i * dest_rowstride;
+ const guchar *src = src_buf + (((i + render_y0) * y_step + y_step/2) >> SCALE_SHIFT) * src_rowstride;
+ guchar *dest = dest_buf + i * dest_rowstride;
x = render_x0 * x_step + x_step / 2;
for (j=0 ; j < (render_x1 - render_x0); j++)
{
- const art_u8 *p = src + (x >> SCALE_SHIFT) * src_channels;
+ const guchar *p = src + (x >> SCALE_SHIFT) * src_channels;
unsigned int a0;
if (src_has_alpha)
}
static void
-composite_pixel (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha,
- int src_has_alpha, int check_size, art_u32 color1, art_u32 color2,
+composite_pixel (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha,
+ int src_has_alpha, int check_size, guint32 color1, guint32 color2,
int r, int g, int b, int a)
{
if (dest_has_alpha)
}
}
-static art_u8 *
+static guchar *
composite_line (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
int x = x_init;
int i, j;
for (i=0; i<n_y; i++)
{
- art_u8 *q = src[i] + x_scaled * src_channels;
+ guchar *q = src[i] + x_scaled * src_channels;
int *line_weights = pixel_weights + n_x * i;
for (j=0; j<n_x; j++)
return dest;
}
-static art_u8 *
+static guchar *
composite_line_22_4a4 (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
int x = x_init;
- art_u8 *src0 = src[0];
- art_u8 *src1 = src[1];
+ guchar *src0 = src[0];
+ guchar *src1 = src[1];
g_return_val_if_fail (src_channels != 3, dest);
g_return_val_if_fail (src_has_alpha, dest);
int x_scaled = x >> SCALE_SHIFT;
unsigned int r, g, b, a, ta;
int *pixel_weights;
- art_u8 *q0, *q1;
+ guchar *q0, *q1;
int w1, w2, w3, w4;
q0 = src0 + x_scaled * 4;
}
#ifdef USE_MMX
-static art_u8 *
+static guchar *
composite_line_22_4a4_mmx_stub (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
- art_u32 mmx_weights[16][8];
+ guint32 mmx_weights[16][8];
int j;
for (j=0; j<16; j++)
#endif /* USE_MMX */
static void
-composite_pixel_color (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha,
- int src_has_alpha, int check_size, art_u32 color1, art_u32 color2,
+composite_pixel_color (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha,
+ int src_has_alpha, int check_size, guint32 color1, guint32 color2,
int r, int g, int b, int a)
{
int dest_r, dest_g, dest_b;
dest[3] = a >> 16;
}
-static art_u8 *
+static guchar *
composite_line_color (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
int x = x_init;
int i, j;
for (i=0; i<n_y; i++)
{
- art_u8 *q = src[i] + x_scaled * src_channels;
+ guchar *q = src[i] + x_scaled * src_channels;
int *line_weights = pixel_weights + n_x * i;
for (j=0; j<n_x; j++)
}
#ifdef USE_MMX
-static art_u8 *
+static guchar *
composite_line_color_22_4a4_mmx_stub (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
- art_u32 mmx_weights[16][8];
+ guint32 mmx_weights[16][8];
int check_shift = get_check_shift (check_size);
int colors[4];
int j;
#endif /* USE_MMX */
static void
-scale_pixel (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha,
- int src_has_alpha, int check_size, art_u32 color1, art_u32 color2,
+scale_pixel (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha,
+ int src_has_alpha, int check_size, guint32 color1, guint32 color2,
int r, int g, int b, int a)
{
if (src_has_alpha)
}
}
-static art_u8 *
+static guchar *
scale_line (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
int x = x_init;
int i, j;
unsigned int r = 0, g = 0, b = 0, a = 0;
for (i=0; i<n_y; i++)
{
- art_u8 *q = src[i] + x_scaled * src_channels;
+ guchar *q = src[i] + x_scaled * src_channels;
int *line_weights = pixel_weights + n_x * i;
for (j=0; j<n_x; j++)
unsigned int r = 0, g = 0, b = 0;
for (i=0; i<n_y; i++)
{
- art_u8 *q = src[i] + x_scaled * src_channels;
+ guchar *q = src[i] + x_scaled * src_channels;
int *line_weights = pixel_weights + n_x * i;
for (j=0; j<n_x; j++)
}
#ifdef USE_MMX
-static art_u8 *
+static guchar *
scale_line_22_33_mmx_stub (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
- art_u32 mmx_weights[16][8];
+ guint32 mmx_weights[16][8];
int j;
for (j=0; j<16; j++)
}
#endif /* USE_MMX */
-static art_u8 *
+static guchar *
scale_line_22_33 (int *weights, int n_x, int n_y,
- art_u8 *dest, art_u8 *dest_end, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, guchar *dest_end, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_init, int x_step, int src_width,
- int check_size, art_u32 color1, art_u32 color2)
+ int check_size, guint32 color1, guint32 color2)
{
int x = x_init;
- art_u8 *src0 = src[0];
- art_u8 *src1 = src[1];
+ guchar *src0 = src[0];
+ guchar *src1 = src[1];
while (dest < dest_end)
{
unsigned int r, g, b;
int x_scaled = x >> SCALE_SHIFT;
int *pixel_weights;
- art_u8 *q0, *q1;
+ guchar *q0, *q1;
int w1, w2, w3, w4;
q0 = src0 + x_scaled * 3;
static void
process_pixel (int *weights, int n_x, int n_y,
- art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha,
- art_u8 **src, int src_channels, art_boolean src_has_alpha,
+ guchar *dest, int dest_x, int dest_channels, int dest_has_alpha,
+ guchar **src, int src_channels, gboolean src_has_alpha,
int x_start, int src_width,
- int check_size, art_u32 color1, art_u32 color2,
+ int check_size, guint32 color1, guint32 color2,
PixopsPixelFunc pixel_func)
{
unsigned int r = 0, g = 0, b = 0, a = 0;
for (j=0; j<n_x; j++)
{
unsigned int ta;
- art_u8 *q;
+ guchar *q;
if (x_start + j < 0)
q = src[i];
}
static void
-pixops_process (art_u8 *dest_buf,
+pixops_process (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int render_y1,
int dest_rowstride,
int dest_channels,
- art_boolean dest_has_alpha,
- const art_u8 *src_buf,
+ gboolean dest_has_alpha,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_channels,
- art_boolean src_has_alpha,
+ gboolean src_has_alpha,
double scale_x,
double scale_y,
int check_x,
int check_y,
int check_size,
- art_u32 color1,
- art_u32 color2,
+ guint32 color1,
+ guint32 color2,
PixopsFilter *filter,
PixopsLineFunc line_func,
PixopsPixelFunc pixel_func)
{
int i, j;
int x, y;
- art_u8 **line_bufs = g_new (art_u8 *, filter->n_y);
+ guchar **line_bufs = g_new (guchar *, filter->n_y);
int x_step = (1 << SCALE_SHIFT) / scale_x;
int y_step = (1 << SCALE_SHIFT) / scale_y;
int y_start = y >> SCALE_SHIFT;
int x_start;
int *run_weights = filter->weights + ((y >> (SCALE_SHIFT - SUBSAMPLE_BITS)) & SUBSAMPLE_MASK) * filter->n_x * filter->n_y * SUBSAMPLE;
- art_u8 *new_outbuf;
- art_u32 tcolor1, tcolor2;
+ guchar *new_outbuf;
+ guint32 tcolor1, tcolor2;
- art_u8 *outbuf = dest_buf + dest_rowstride * i;
- art_u8 *outbuf_end = outbuf + dest_channels * (render_x1 - render_x0);
+ guchar *outbuf = dest_buf + dest_rowstride * i;
+ guchar *outbuf_end = outbuf + dest_channels * (render_x1 - render_x0);
if (((i + check_y) >> check_shift) & 1)
{
for (j=0; j<filter->n_y; j++)
{
if (y_start < 0)
- line_bufs[j] = (art_u8 *)src_buf;
+ line_bufs[j] = (guchar *)src_buf;
else if (y_start < src_height)
- line_bufs[j] = (art_u8 *)src_buf + src_rowstride * y_start;
+ line_bufs[j] = (guchar *)src_buf + src_rowstride * y_start;
else
- line_bufs[j] = (art_u8 *)src_buf + src_rowstride * (src_height - 1);
+ line_bufs[j] = (guchar *)src_buf + src_rowstride * (src_height - 1);
y_start++;
}
}
void
-pixops_composite_color (art_u8 *dest_buf,
+pixops_composite_color (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int render_y1,
int dest_rowstride,
int dest_channels,
- art_boolean dest_has_alpha,
- const art_u8 *src_buf,
+ gboolean dest_has_alpha,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_channels,
- art_boolean src_has_alpha,
+ gboolean src_has_alpha,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha,
int check_x,
int check_y,
int check_size,
- art_u32 color1,
- art_u32 color2)
+ guint32 color1,
+ guint32 color2)
{
PixopsFilter filter;
PixopsLineFunc line_func;
#ifdef USE_MMX
- art_boolean found_mmx = pixops_have_mmx();
+ gboolean found_mmx = pixops_have_mmx();
#endif
g_return_if_fail (!(dest_channels == 3 && dest_has_alpha));
pixops_scale (dest_buf, render_x0, render_y0, render_x1, render_y1,
dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels,
- src_has_alpha, scale_x, scale_y, filter_level);
+ src_has_alpha, scale_x, scale_y, interp_type);
- switch (filter_level)
+ switch (interp_type)
{
- case ART_FILTER_NEAREST:
+ case GDK_INTERP_NEAREST:
pixops_composite_color_nearest (dest_buf, render_x0, render_y0, render_x1, render_y1,
dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha,
check_x, check_y, check_size, color1, color2);
return;
- case ART_FILTER_TILES:
+ case GDK_INTERP_TILES:
tile_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.);
break;
- case ART_FILTER_BILINEAR:
+ case GDK_INTERP_BILINEAR:
bilinear_make_fast_weights (&filter, scale_x, scale_y, overall_alpha / 255.);
break;
- case ART_FILTER_HYPER:
+ case GDK_INTERP_HYPER:
bilinear_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.);
break;
}
}
void
-pixops_composite (art_u8 *dest_buf,
+pixops_composite (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int render_y1,
int dest_rowstride,
int dest_channels,
- art_boolean dest_has_alpha,
- const art_u8 *src_buf,
+ gboolean dest_has_alpha,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_channels,
- art_boolean src_has_alpha,
+ gboolean src_has_alpha,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha)
{
PixopsFilter filter;
PixopsLineFunc line_func;
#ifdef USE_MMX
- art_boolean found_mmx = pixops_have_mmx();
+ gboolean found_mmx = pixops_have_mmx();
#endif
g_return_if_fail (!(dest_channels == 3 && dest_has_alpha));
pixops_scale (dest_buf, render_x0, render_y0, render_x1, render_y1,
dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels,
- src_has_alpha, scale_x, scale_y, filter_level);
+ src_has_alpha, scale_x, scale_y, interp_type);
- switch (filter_level)
+ switch (interp_type)
{
- case ART_FILTER_NEAREST:
+ case GDK_INTERP_NEAREST:
pixops_composite_nearest (dest_buf, render_x0, render_y0, render_x1, render_y1,
dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels,
src_has_alpha, scale_x, scale_y, overall_alpha);
return;
- case ART_FILTER_TILES:
+ case GDK_INTERP_TILES:
tile_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.);
break;
- case ART_FILTER_BILINEAR:
+ case GDK_INTERP_BILINEAR:
bilinear_make_fast_weights (&filter, scale_x, scale_y, overall_alpha / 255.);
break;
- case ART_FILTER_HYPER:
+ case GDK_INTERP_HYPER:
bilinear_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.);
break;
}
}
void
-pixops_scale (art_u8 *dest_buf,
+pixops_scale (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int render_y1,
int dest_rowstride,
int dest_channels,
- art_boolean dest_has_alpha,
- const art_u8 *src_buf,
+ gboolean dest_has_alpha,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_channels,
- art_boolean src_has_alpha,
+ gboolean src_has_alpha,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level)
+ GdkInterpType interp_type)
{
PixopsFilter filter;
PixopsLineFunc line_func;
#ifdef USE_MMX
- art_boolean found_mmx = pixops_have_mmx();
+ gboolean found_mmx = pixops_have_mmx();
#endif
g_return_if_fail (!(dest_channels == 3 && dest_has_alpha));
if (scale_x == 0 || scale_y == 0)
return;
- switch (filter_level)
+ switch (interp_type)
{
- case ART_FILTER_NEAREST:
+ case GDK_INTERP_NEAREST:
pixops_scale_nearest (dest_buf, render_x0, render_y0, render_x1, render_y1,
dest_rowstride, dest_channels, dest_has_alpha,
src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha,
scale_x, scale_y);
return;
- case ART_FILTER_TILES:
+ case GDK_INTERP_TILES:
tile_make_weights (&filter, scale_x, scale_y, 1.0);
break;
- case ART_FILTER_BILINEAR:
+ case GDK_INTERP_BILINEAR:
bilinear_make_fast_weights (&filter, scale_x, scale_y, 1.0);
break;
- case ART_FILTER_HYPER:
+ case GDK_INTERP_HYPER:
bilinear_make_weights (&filter, scale_x, scale_y, 1.0);
break;
}
-#include <libart_lgpl/art_misc.h>
-#include <libart_lgpl/art_filterlevel.h>
+#ifndef PIXOPS_H
+#define PIXOPS_H
+
+#include <glib.h>
+#include "gdk-pixbuf.h"
+
+\f
/* Scale src_buf from src_width / src_height by factors scale_x, scale_y
* and composite the portion corresponding to
* render_x, render_y, render_width, render_height in the new
* coordinate system into dest_buf starting at 0, 0
*/
-void pixops_composite (art_u8 *dest_buf,
+void pixops_composite (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int dest_rowstride,
int dest_channels,
int dest_has_alpha,
- const art_u8 *src_buf,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_has_alpha,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha);
/* Scale src_buf from src_width / src_height by factors scale_x, scale_y
* coordinate system against a checkboard with checks of size check_size
* of the colors color1 and color2 into dest_buf starting at 0, 0
*/
-void pixops_composite_color (art_u8 *dest_buf,
+void pixops_composite_color (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int dest_rowstride,
int dest_channels,
int dest_has_alpha,
- const art_u8 *src_buf,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_has_alpha,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level,
+ GdkInterpType interp_type,
int overall_alpha,
int check_x,
int check_y,
int check_size,
- art_u32 color1,
- art_u32 color2);
+ guint32 color1,
+ guint32 color2);
/* Scale src_buf from src_width / src_height by factors scale_x, scale_y
* and composite the portion corresponding to
* render_x, render_y, render_width, render_height in the new
* coordinate system into dest_buf starting at 0, 0
*/
-void pixops_scale (art_u8 *dest_buf,
+void pixops_scale (guchar *dest_buf,
int render_x0,
int render_y0,
int render_x1,
int dest_rowstride,
int dest_channels,
int dest_has_alpha,
- const art_u8 *src_buf,
+ const guchar *src_buf,
int src_width,
int src_height,
int src_rowstride,
int src_has_alpha,
double scale_x,
double scale_y,
- ArtFilterLevel filter_level);
+ GdkInterpType interp_type);
+
+\f
+#endif
switch (j)
{
- case ART_FILTER_NEAREST:
+ case GDK_INTERP_NEAREST:
printf (" NEAREST\n");
break;
- case ART_FILTER_TILES:
+ case GDK_INTERP_TILES:
printf (" TILES\n");
break;
- case ART_FILTER_BILINEAR:
+ case GDK_INTERP_BILINEAR:
printf (" BILINEAR\n");
break;
- case ART_FILTER_HYPER:
+ case GDK_INTERP_HYPER:
printf (" HYPER\n");
break;
}
dest_buf = malloc(dest_rowstride * dest_height);
memset (dest_buf, 0x80, dest_rowstride * dest_height);
- for (filter_level = ART_FILTER_NEAREST ; filter_level <= ART_FILTER_HYPER; filter_level++)
+ for (filter_level = GDK_INTERP_NEAREST ; filter_level <= GDK_INTERP_HYPER; filter_level++)
{
printf ("src_channels = %d (%s); dest_channels = %d (%s); filter_level=",
src_channels, src_has_alpha ? "alpha" : "no alpha",
dest_channels, dest_has_alpha ? "alpha" : "no alpha");
switch (filter_level)
{
- case ART_FILTER_NEAREST:
- printf ("ART_FILTER_NEAREST\n");
+ case GDK_INTERP_NEAREST:
+ printf ("GDK_INTERP_NEAREST\n");
break;
- case ART_FILTER_TILES:
- printf ("ART_FILTER_TILES\n");
+ case GDK_INTERP_TILES:
+ printf ("GDK_INTERP_TILES\n");
break;
- case ART_FILTER_BILINEAR:
- printf ("ART_FILTER_BILINEAR\n");
+ case GDK_INTERP_BILINEAR:
+ printf ("GDK_INTERP_BILINEAR\n");
break;
- case ART_FILTER_HYPER:
- printf ("ART_FILTER_HYPER\n");
+ case GDK_INTERP_HYPER:
+ printf ("GDK_INTERP_HYPER\n");
break;
}
#include <config.h>
#include <stdio.h>
#include <string.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
#if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
#define LITTLE
no alpha
*/
static void
-rgb1 (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb1 (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
with alpha
*/
static void
-rgb1a (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb1a (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
no alpha
*/
static void
-rgb8 (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb8 (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
with alpha
*/
static void
-rgb8a (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb8a (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in lsb format
*/
static void
-rgb565lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb565lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in msb format
*/
static void
-rgb565msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb565msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in lsb format
*/
static void
-rgb565alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb565alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in msb format
*/
static void
-rgb565amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb565amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in lsb format
*/
static void
-rgb555lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb555lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in msb format
*/
static void
-rgb555msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb555msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in lsb format
*/
static void
-rgb555alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb555alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
data in msb format
*/
static void
-rgb555amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb555amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
static void
-rgb888alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb888alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
}
static void
-rgb888lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb888lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
}
static void
-rgb888amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb888amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
}
static void
-rgb888msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap)
+rgb888msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap)
{
int xx, yy;
int width, height;
run quite slow
*/
static void
-convert_real_slow (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *cmap, int alpha)
+convert_real_slow (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *cmap, int alpha)
{
int xx, yy;
int width, height;
}
}
-typedef void (* cfunc) (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *cmap);
+typedef void (* cfunc) (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *cmap);
static cfunc convert_map[] = {
rgb1,rgb1,rgb1a,rgb1a,
conversion function.
*/
static void
-rgbconvert (GdkImage *image, art_u8 *pixels, int rowstride, int alpha, GdkColormap *cmap)
+rgbconvert (GdkImage *image, guchar *pixels, int rowstride, int alpha, GdkColormap *cmap)
{
int index = (image->byte_order == GDK_MSB_FIRST) | (alpha != 0) << 1;
int bank=5; /* default fallback converter */
* be undefined.
*
* Return value: The same pixbuf as @dest if it was non-NULL, or a newly-created
- * pixbuf with a reference count of 1 if no destination pixbuf was specified.
+ * pixbuf with a reference count of 1 if no destination pixbuf was specified; in
+ * the latter case, NULL will be returned if not enough memory could be
+ * allocated for the pixbuf to be created.
**/
GdkPixbuf *
gdk_pixbuf_get_from_drawable (GdkPixbuf *dest,
{
GdkWindowType window_type;
int src_width, src_height;
- ArtPixBuf *apb = NULL;
GdkImage *image;
int rowstride, bpp, alpha;
if (!dest)
g_return_val_if_fail (dest_x == 0 && dest_y == 0, NULL);
else {
- apb = dest->art_pixbuf;
-
- g_return_val_if_fail (apb->format == ART_PIX_RGB, NULL);
- g_return_val_if_fail (apb->n_channels == 3 || apb->n_channels == 4, NULL);
- g_return_val_if_fail (apb->bits_per_sample == 8, NULL);
+ g_return_val_if_fail (dest->colorspace == GDK_COLORSPACE_RGB, NULL);
+ g_return_val_if_fail (dest->n_channels == 3 || dest->n_channels == 4, NULL);
+ g_return_val_if_fail (dest->bits_per_sample == 8, NULL);
}
/* Coordinate sanity checks */
if (dest) {
g_return_val_if_fail (dest_x >= 0 && dest_y >= 0, NULL);
- g_return_val_if_fail (dest_x + width <= apb->width, NULL);
- g_return_val_if_fail (dest_y + height <= apb->height, NULL);
+ g_return_val_if_fail (dest_x + width <= dest->width, NULL);
+ g_return_val_if_fail (dest_y + height <= dest->height, NULL);
}
if (window_type != GDK_WINDOW_PIXMAP) {
/* Get Image in ZPixmap format (packed bits). */
image = gdk_image_get (src, src_x, src_y, width, height);
- g_return_val_if_fail( image != NULL, NULL);
+ g_return_val_if_fail (image != NULL, NULL);
/* Create the pixbuf if needed */
if (!dest) {
- dest = gdk_pixbuf_new (ART_PIX_RGB, FALSE, 8, width, height);
+ dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height);
if (!dest) {
gdk_image_destroy(image);
return NULL;
}
-
- apb = dest->art_pixbuf;
}
/* Get the colormap if needed */
if (window_type != GDK_WINDOW_PIXMAP)
cmap = gdk_window_get_colormap (src);
- alpha = gdk_pixbuf_get_has_alpha(dest);
- rowstride = gdk_pixbuf_get_rowstride(dest);
- bpp = alpha?4:3;
+ alpha = dest->has_alpha;
+ rowstride = dest->rowstride;
+ bpp = alpha ? 4 : 3;
/* we offset into the image data based on the position we are retrieving from */
- rgbconvert(image, gdk_pixbuf_get_pixels(dest) +
- (dest_y * rowstride) + (dest_x * bpp),
- rowstride,
- alpha,
- cmap);
+ rgbconvert (image, dest->pixels +
+ (dest_y * rowstride) + (dest_x * bpp),
+ rowstride,
+ alpha,
+ cmap);
gdk_image_destroy(image);
#include <config.h>
#include <gdk/gdk.h>
-#include <libart_lgpl/art_rect.h>
-#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-private.h"
\f
int width, int height,
int alpha_threshold)
{
- ArtPixBuf *apb;
GdkGC *gc;
GdkColor color;
int x, y;
int status;
g_return_if_fail (pixbuf != NULL);
- apb = pixbuf->art_pixbuf;
-
- g_return_if_fail (apb->format == ART_PIX_RGB);
- g_return_if_fail (apb->n_channels == 3 || apb->n_channels == 4);
- g_return_if_fail (apb->bits_per_sample == 8);
+ g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
+ g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4);
+ g_return_if_fail (pixbuf->bits_per_sample == 8);
g_return_if_fail (bitmap != NULL);
g_return_if_fail (width >= 0 && height >= 0);
- g_return_if_fail (src_x >= 0 && src_x + width <= apb->width);
- g_return_if_fail (src_y >= 0 && src_y + height <= apb->height);
+ g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width);
+ g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height);
g_return_if_fail (alpha_threshold >= 0 && alpha_threshold <= 255);
gc = gdk_gc_new (bitmap);
- if (!apb->has_alpha) {
+ if (!pixbuf->has_alpha) {
color.pixel = (alpha_threshold == 255) ? 0 : 1;
gdk_gc_set_foreground (gc, &color);
gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height);
gdk_gc_set_foreground (gc, &color);
for (y = 0; y < height; y++) {
- p = (apb->pixels + (y + src_y) * apb->rowstride + src_x * apb->n_channels
- + apb->n_channels - 1);
+ p = (pixbuf->pixels + (y + src_y) * pixbuf->rowstride + src_x * pixbuf->n_channels
+ + pixbuf->n_channels - 1);
start = 0;
start_status = *p < alpha_threshold;
start_status = status;
}
- p += apb->n_channels;
+ p += pixbuf->n_channels;
}
if (!start_status)
/* Creates a buffer by stripping the alpha channel of a pixbuf */
static guchar *
-remove_alpha (ArtPixBuf *apb, int x, int y, int width, int height, int *rowstride)
+remove_alpha (GdkPixbuf *pixbuf, int x, int y, int width, int height, int *rowstride)
{
guchar *buf;
int xx, yy;
guchar *src, *dest;
- g_assert (apb->n_channels == 4);
- g_assert (apb->has_alpha);
+ g_assert (pixbuf->n_channels == 4);
+ g_assert (pixbuf->has_alpha);
g_assert (width > 0 && height > 0);
- g_assert (x >= 0 && x + width <= apb->width);
- g_assert (y >= 0 && y + height <= apb->height);
+ g_assert (x >= 0 && x + width <= pixbuf->width);
+ g_assert (y >= 0 && y + height <= pixbuf->height);
*rowstride = 4 * ((width * 3 + 3) / 4);
buf = g_new (guchar, *rowstride * height);
for (yy = 0; yy < height; yy++) {
- src = apb->pixels + apb->rowstride * (yy + y) + x * apb->n_channels;
+ src = pixbuf->pixels + pixbuf->rowstride * (yy + y) + x * pixbuf->n_channels;
dest = buf + *rowstride * yy;
for (xx = 0; xx < width; xx++) {
GdkRgbDither dither,
int x_dither, int y_dither)
{
- ArtPixBuf *apb;
guchar *buf;
int rowstride;
g_return_if_fail (pixbuf != NULL);
- apb = pixbuf->art_pixbuf;
-
- g_return_if_fail (apb->format == ART_PIX_RGB);
- g_return_if_fail (apb->n_channels == 3 || apb->n_channels == 4);
- g_return_if_fail (apb->bits_per_sample == 8);
+ g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
+ g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4);
+ g_return_if_fail (pixbuf->bits_per_sample == 8);
g_return_if_fail (drawable != NULL);
g_return_if_fail (gc != NULL);
g_return_if_fail (width >= 0 && height >= 0);
- g_return_if_fail (src_x >= 0 && src_x + width <= apb->width);
- g_return_if_fail (src_y >= 0 && src_y + height <= apb->height);
+ g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width);
+ g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height);
if (width == 0 || height == 0)
return;
- /* This will have to be modified once libart supports other image types.
+ /* This will have to be modified once we support other image types.
* Also, GdkRGB does not have gdk_draw_rgb_32_image_dithalign(), so we
- * have to pack the buffer first.
+ * have to pack the buffer first. Sigh.
*/
- if (apb->has_alpha)
- buf = remove_alpha (apb, src_x, src_y, width, height, &rowstride);
+ if (pixbuf->has_alpha)
+ buf = remove_alpha (pixbuf, src_x, src_y, width, height, &rowstride);
else {
- buf = apb->pixels + src_y * apb->rowstride + src_x * 3;
- rowstride = apb->rowstride;
+ buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 3;
+ rowstride = pixbuf->rowstride;
}
gdk_draw_rgb_image_dithalign (drawable, gc,
buf, rowstride,
x_dither, y_dither);
- if (apb->has_alpha)
+ if (pixbuf->has_alpha)
g_free (buf);
}
GdkRgbDither dither,
int x_dither, int y_dither)
{
- ArtPixBuf *apb;
GdkBitmap *bitmap = NULL;
GdkGC *gc;
g_return_if_fail (pixbuf != NULL);
- apb = pixbuf->art_pixbuf;
-
- g_return_if_fail (apb->format == ART_PIX_RGB);
- g_return_if_fail (apb->n_channels == 3 || apb->n_channels == 4);
- g_return_if_fail (apb->bits_per_sample == 8);
+ g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB);
+ g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4);
+ g_return_if_fail (pixbuf->bits_per_sample == 8);
g_return_if_fail (drawable != NULL);
g_return_if_fail (width >= 0 && height >= 0);
- g_return_if_fail (src_x >= 0 && src_x + width <= apb->width);
- g_return_if_fail (src_y >= 0 && src_y + height <= apb->height);
+ g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width);
+ g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height);
if (width == 0 || height == 0)
return;
gc = gdk_gc_new (drawable);
- if (apb->has_alpha) {
+ if (pixbuf->has_alpha) {
/* Right now we only support GDK_PIXBUF_ALPHA_BILEVEL, so we
* unconditionally create the clipping mask.
*/
if (bitmap)
gdk_bitmap_unref (bitmap);
+
gdk_gc_unref (gc);
}
/**
* gdk_pixbuf_render_pixmap_and_mask:
- * @pixbuf: A pixbuf
+ * @pixbuf: A pixbuf.
* @pixmap_return: Return value for the created pixmap.
* @mask_return: Return value for the created mask.
* @alpha_threshold: Threshold value for opacity values.
* function; applications that need to render pixbufs with dither offsets or to
* given drawables should use gdk_pixbuf_render_to_drawable_alpha() or
* gdk_pixbuf_render_to_drawable(), and gdk_pixbuf_render_threshold_alpha().
+ *
+ * If the pixbuf does not have an alpha channel, then *@mask_return will be set
+ * to NULL.
**/
void
gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf,
GdkPixmap **pixmap_return, GdkBitmap **mask_return,
int alpha_threshold)
{
- ArtPixBuf *apb;
-
g_return_if_fail (pixbuf != NULL);
- apb = pixbuf->art_pixbuf;
-
if (pixmap_return) {
GdkGC *gc;
- *pixmap_return = gdk_pixmap_new (NULL, apb->width, apb->height,
+ *pixmap_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height,
gdk_rgb_get_visual ()->depth);
gc = gdk_gc_new (*pixmap_return);
gdk_pixbuf_render_to_drawable (pixbuf, *pixmap_return, gc,
0, 0, 0, 0,
- apb->width, apb->height,
+ pixbuf->width, pixbuf->height,
GDK_RGB_DITHER_NORMAL,
0, 0);
gdk_gc_unref (gc);
}
if (mask_return) {
- *mask_return = gdk_pixmap_new (NULL, apb->width, apb->height, 1);
- gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return,
- 0, 0, 0, 0,
- apb->width, apb->height,
- alpha_threshold);
+ if (pixbuf->has_alpha) {
+ *mask_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, 1);
+ gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return,
+ 0, 0, 0, 0,
+ pixbuf->width, pixbuf->height,
+ alpha_threshold);
+ } else
+ *mask_return = NULL;
}
}
#include <config.h>
#include <gtk/gtksignal.h>
+#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-loader.h"
#include "gdk-pixbuf-io.h"
projects / gtk4.git / commitdiff